Competency Matrix

Explorer
Beginner
Practicioner
Experienced
Professional
Senior
Problem decomposition
Problem decomposition:
Explorer
Description:
Does not understand the relation between code and flowcharts.
 
Problem decomposition:
Beginner
Description:
Able to convert a simple flowchart into code. Able to break up a simple problem into a series of steps or logical units.
Problem decomposition:
Practicioner
Description:
Able to break up the given problem domain and design a solution. Uses parameters extensively. Puts effort into following the Single Responsibitily Principle.
Problem decomposition:
Experienced
Description:
Uses dependency injection. Able think about larger units and plan their interfaces.
Problem decomposition:
Professional
Description:
Able to think about components, layers, services, and APIs. Able to design loosely coupled systems that span multiple technologies/platforms.
Problem decomposition:
Senior
Description:
Able to visualize and design complex systems with multiple product lines and integrations with external systems. Knows advanced coupling techniques like messaging, async calls. Able to design operations support systems like monitoring, reporting, failovers etc.
Software design
Clean code
Clean code:
Explorer
Description:
Doesn't know what clean code means and produces code that is far from clean.
 
Clean code:
Beginner
Description:
Puts effort into creating descriptive variable/method names and tries to organize code into logical building blocks (e.g. functions, classes, modules).
 
Clean code:
Practicioner
Description:
Creates descriptive variable/method names and organizes code into logical building blocks (e.g. functions, classes, modules). Able to refactor short programs.
Clean code:
Experienced
Description:
Pays attention to have short (less than 30 lines) and readable methods. Able to improve code readability and reduce complexity in medium-sized projects. Writes useful and properly placed comments, has no dead code.
Clean code:
Professional
Description:
Able to improve code readability and reduce complexity, and able to create a more expressive internal architecture or object model to improve extensibility. Able to transform control structures.
Clean code:
Senior
Description:
Always keeps in mind clean code considerations, has a magic inner sense to recognize and fix code formatting errors. Always leaves cleaner code behind.
Error handling
Error handling:
Explorer
Description:
Only codes the happy case.
 
Error handling:
Beginner
Description:
Knows when to use conditions and when exception handling when dealing with errors.
Error handling:
Practicioner
Description:
Uses specific exception types in proper order (from specific to general).
Error handling:
Experienced
Description:
Uses finally or try-with-resources properly. Not just prints/logs errors but ensures that errors/exceptions leave the program in a stable state, resources, connections and memory is all cleaned up properly.
Error handling:
Professional
Description:
Can work with exceptions in modularized programs, throw (raise) and catch exceptions through layers properly.
Error handling:
Senior
Description:
Maintain consistent exception handling strategy in all layers of code, come up with guidelines on exception handling for an entire system, knows when to introduce user defined exceptions and uses them properly.
Security
Security:
Explorer
Description:
Does not know about security issues.
Security:
Beginner
Description:
Security:
Practicioner
Description:
Security:
Experienced
Description:
Security:
Professional
Description:
Security:
Senior
Description:
Data structures
Data structures:
Explorer
Description:
Doesn't know the difference between a list and a stack.
 
Data structures:
Beginner
Description:
Knows about the most popular abstract data types, like lists, sets, maps, queues, and stacks.
Data structures:
Practicioner
Description:
Knows about and understands the performance consequences of different implementations of lists (based on arrays or linked lists).
Data structures:
Experienced
Description:
Able to implement 3+ ADTs including graphs and trees
Data structures:
Professional
Description:
Knows about 10+ complex data structures including different types of trees, heaps, graphs, and hashes. Able to understand and implement complex ADTs (like binary search trees) on first read.
Data structures:
Senior
Description:
Knows about 20+ complex data structures including different types of trees, B-trees, heaps, graphs, and hashes. Able to understand and implement really complex ADTs (like red-black trees) on first read.
Computer science
Algorithms
Algorithms:
Explorer
Description:
Cannot implement the simplest algorithm.
 
Algorithms:
Beginner
Description:
Can implement basic algorithms (like finding maximum), and can understand a few simple "named" algorithms (like bubble sort or Fibonacci without recursion).
Algorithms:
Practicioner
Description:
Can translate into code a simple text assignment into a basic algorithm. Can implement a few simple "named" algorithms (like bubble sort, different methods of searching prime numbers).
Algorithms:
Experienced
Description:
Knows about big O complexity, can tell the complexity of a code if its O(N^x). Has knowlegde of 3+ algorithms, including simple and efficient sorts.
Algorithms:
Professional
Description:
Able to calculate non-trivial time complexities. Able to implement at least 6 "named" algorithms including at least one of these:simple search, efficient search, search in a graph, search in a tree.
Algorithms:
Senior
Description:
Knows and can implement complex algorithms in areas like dynamic programming, computational geometry, etc.
Procedural
Procedural:
Explorer
Description:
Doesn't know what variables are and how to use control structures.
 
Procedural:
Beginner
Description:
Able to use variables and basic control stuctures (loops and conditional stuctures).
 
Procedural:
Practicioner
Description:
Understands global and local scopes. Uses all kinds of available control structures. Understands the differentce between statements and expressions.
Procedural:
Experienced
Description:
Understands arguments and return values. Writes parametrized functions.
Procedural:
Professional
Description:
Writes proper functions. Understands scoping in details. Understands call stack.
Procedural:
Senior
Description:
Writes modular, well organized code. Understands the difference between pass-by-value and pass-by-reference.
Programming paradigms
Object-oriented
Object-oriented:
Explorer
Description:
Doesn't know what objects and classes are.
Object-oriented:
Beginner
Description:
Understands the concepts of classes and instances and is able to use class and instance members properly.
Object-oriented:
Practicioner
Description:
Understands and able to use encapsulation, abstraction, and inheritance.
Object-oriented:
Experienced
Description:
Understands polymorphism in detail. Confident in designing a class structure for a complicated domain.
Object-oriented:
Professional
Description:
Solid knowledge of SOLID principles with detailed examples and instant applications.
Object-oriented:
Senior
Description:
Knows deeper details about the implementation of OOP itself. Able to provide sophisticated critique of OOP.
Functional
Functional:
Explorer
Description:
Doesn't understand recursion. Doesn't know how to trigger, observe and handle events in a program. Ignorant about functional programming techniques.
 
Functional:
Beginner
Description:
Understands recursion.
Functional:
Practicioner
Description:
Understands event listeners and callback functions.
Functional:
Experienced
Description:
Understands first-class functions, anonymous functions, and higher-order functions. Uses the most important higher-order functions (like map, reduce, and filter).
Functional:
Professional
Description:
Understands closures. Uses higher-order functions exensively.
Functional:
Senior
Description:
Understands tail call optimization. Understands the role of immutable data structures. Avoids using imperative code at all.
Python
Python:
Explorer
Description:
Cannot run anything in Python.
 
Python:
Beginner
Description:
Puts effort into using the proper basic variable types and control structures. Understands modules, packages, and virtual environments.
 
Python:
Practicioner
Description:
Uses basic variable types, control structures, statements, and expressions properly.
Python:
Experienced
Description:
Understands Python's type system. Knows some major packages.
Python:
Professional
Description:
Knows about Python's object-oriented and functional capabilities. Knows about metaprogramming and metaobjects.
Python:
Senior
Description:
Understands in detail the working of the Python interpreter (binding, memory management, etc.). Familiar with the larger Python ecosystem.
Programming languages
Java
Java:
Explorer
Description:
Cannot run anything in Java.
Java:
Beginner
Description:
Able to compile and run Java code from the command line. Able to create basic classes, uses operators, and control structures. Understands Java's type system and arrays. Able to use arrays. Knows and able to use some implementations of List, Set, and Map.
Java:
Practicioner
Description:
Able to use Java's OOP features. Uses enum classes. Understands the basic of generics. Understands the structure of Collections API.
Java:
Experienced
Description:
Able to write and deploy web applications in Java using Servlets. Uses databases in Java via JDBC. Knows the basic workings of the Java runtime. Knows some major libraries from the Java ecosystem (like dependency management, testing, logging).
Java:
Professional
Description:
Understands Java 8's functional features. Able to use the Stream API. Able to write generic code, use reflection and create annotations. Understands nested and anonymous classes.
Java:
Senior
Description:
Knows about the newest and future Java features. Able to write concurrent code. Knows details about the workings of the compiler and the JVM. Familiar with the Java ecosystem.
C#
C#:
Explorer
Description:
Cannot run anything in C#.
C#:
Beginner
Description:
Able to compile and run C# code from Visual Studio. Able to create basic classes, uses operators, and control structures. Able to use arrays. Knows and able to use some implementations of List, Queue, Stack, and Dictionary.
C#:
Practicioner
Description:
Able to use C#'s OOP features. Understands basic generic code. Understands the structure of Collections namespace.
C#:
Experienced
Description:
Able to write and deploy web applications in C# using ASP.NET. Able to write WPF desktop application. Uses databases in C# via ADO.NET or Entity Framework.
C#:
Professional
Description:
Uses both OOP concepts (like polymorphism) and Events (for Visual Components) in C# with ease. Proper error handling. Able to use LINQ with ease.
C#:
Senior
Description:
Able to write generic code. Able to use reflection. Able to use attributes properly. Understands the concept of Threading and Concurrent programming. Able to use TPL. Knows about the newest (.NET core, ASP.NET core) and future C# features.
C++
C++:
Explorer
Description:
Cannot run anything in C++.
C++:
Beginner
Description:
C++:
Practicioner
Description:
Uses variable types (pointers, references, arrays, strings) confidently. Able to write functions and classes/objects properly.
C++:
Experienced
Description:
Uses OOP concepts (like inheritance, multiple inheritance) and Templates, STL with ease. Proper error handling.
C++:
Professional
Description:
C++:
Senior
Description:
SQL
SQL:
Explorer
Description:
Doesn't know the basic SQL commands.
SQL:
Beginner
Description:
Able to create and modify databases and datatables in an RDBMS. Writes simple queries with SELECT statement.
SQL:
Practicioner
Description:
SQL:
Experienced
Description:
Able to design and implement normalized database schemas. Writes advanced SELECT queries (with JOIN, GROUP, etc) and able to aggregate data. Uses indexes properly.
SQL:
Professional
Description:
SQL:
Senior
Description:
Can do basic database administration, performance optimization, index optimization, write advanced select queries, able to replace cursor usage with relational SQL, understands how data is stored internally, understands how indexes are stored internally, understands how databases can be mirrored, replicated etc. Understands how the two phase commit works.
HTML + CSS
HTML + CSS:
Explorer
Description:
Doesn't know the basic HTML tags.
HTML + CSS:
Beginner
Description:
HTML + CSS:
Practicioner
Description:
Able to build a basic webpage from HTML tags - with forms, tables, different layouts. Uses simple (not cascaded) styles to separate styling (like font styling, colours). Result may differ in different browsers.
HTML + CSS:
Experienced
Description:
HTML + CSS:
Professional
Description:
Able to build a complex webpage with table-less and responsive design, with cascaded styles in CSS files. The result is cross-browser compatible.
HTML + CSS:
Senior
Description:
JavaScript
JavaScript:
Explorer
Description:
Cannot run anything in JavaScript.
JavaScript:
Beginner
Description:
Knows the basic variable types, control structures, basic arithmetic, comparison, and boolean operators, and the basic usage of functions, arrays and objects. Uses error handling. Knows how to use JS in HTML.
JavaScript:
Practicioner
Description:
Uses types and control structures properly. Able to use JSON and LocalStorage. Able to use JavaScript for DOM manipulation and event handling via normal requests. Knows the most important ES6 features.
JavaScript:
Experienced
Description:
Able to use JavaScript for DOM manipulation via AJAX. Knows the most of the ES6 features. Understands closures.
JavaScript:
Professional
Description:
Understands prototypes. Knows one or two major JS frameworks (like jQuery, React, AngularJs).
JavaScript:
Senior
Description:
Knows well the JS ecosystem. Understands Node.js and the largest JS frameworks.
Unix
Unix:
Explorer
Description:
 
Unix:
Beginner
Description:
Can use the online documentation (whatis, apropos, man, info, etc).
Unix:
Practicioner
Description:
Familiar with at least one package manager and one window manager / desktop environment.
Unix:
Experienced
Description:
Can use job control, common utilities, redirection, regular expressions.
Unix:
Professional
Description:
Can write shell scripts, familiar with the filesystem hierarchy.
Unix:
Senior
Description:
Familiar with multiple file systems, init systems. Familiar with vendor-specific features (zones, dtrace, jails, cgroups, etc).
Software engineering
Debugging
Debugging:
Explorer
Description:
Cannot recognize basic error messages, cannot debug (not even with print).
 
Debugging:
Beginner
Description:
Recognizes basic error messages, can debug with printing out variable values.
 
Debugging:
Practicioner
Description:
Can recognize error messages, able to use the debugger, uses breakpoints and watch expressions.
Debugging:
Experienced
Description:
Uses debugger confidently, knows how to use conditional breakpoints. Understands the importance of logging.
Debugging:
Professional
Description:
Able recognize advanced error messages, even in large frameworks. Uses logging frameworks.
Debugging:
Senior
Description:
Can recognize advanced error messages, can debug confidently and quickly with the debugger using conditional breakpoints and putting the breakpoints at right places.
Testing
Testing:
Explorer
Description:
Thinks that all testing is the job of the testers.
Testing:
Beginner
Description:
Able to define automated unit tests.
Testing:
Practicioner
Description:
Writes automated unit tests and comes up with good unit test cases. Able to use stubs or mocks where needed.
Testing:
Experienced
Description:
Writes automated unit and integrations tests and comes up with good test cases.
Testing:
Professional
Description:
Writes automated unit or integration tests in TDD manner.
Testing:
Senior
Description:
Understands and is able to setup automated functional, load/performance and UI tests.
Git
Git:
Explorer
Description:
Makes copies of the source files to keep versions, sends these over email/chat to share with others.
 
Git:
Beginner
Description:
Able to use most basic Git functionalities to track changes, using a remote repository to share code with others.
 
Git:
Practicioner
Description:
Knows the basics of branching. Uses Git in a basic way with a small team, can handle merge conflicts.
Git:
Experienced
Description:
Uses specific Git workflows with branching. Able to use advanced commands.
Git:
Professional
Description:
Uses advanced Git commands. Able to deal with multiple remotes and complicated situations.
Git:
Senior
Description:
A Git ninja who knows the detailed workings of the Git commands and its internal data structures. Able to deal with super complicated situations.
Networks
Networks:
Explorer
Description:
Networks:
Beginner
Description:
Networks:
Practicioner
Description:
Networks:
Experienced
Description:
Networks:
Professional
Description:
Networks:
Senior
Description:
DevOps
DevOps:
Explorer
Description:
DevOps:
Beginner
Description:
DevOps:
Practicioner
Description:
DevOps:
Experienced
Description:
DevOps:
Professional
Description:
DevOps:
Senior
Description:
Online search
Online search:
Explorer
Description:
Doesn't know how to search for something online.
 
Online search:
Beginner
Description:
Puts effort into finding the proper search phrase. Knows about basic search operators.
Online search:
Practicioner
Description:
Usually finds the proper search phrase. Uses basic search operators confidently. Can navigate in well-structured document/post to find information. Puts effort into differentiating between valuable and invaluable information.
Online search:
Experienced
Description:
Can differentiate between valuable and invaluable information. Can navigate in document/post to find information.
Online search:
Professional
Description:
Always finds quickly the proper search phrase. Uses some advanced operators as well. Puts effort into checking the creditibility of the source.
Online search:
Senior
Description:
Uses advanced operators confidently. Knows various techniques to check the creditibility of the source.
Programming environment
Geekness
Geekness:
Explorer
Description:
Slow user of the computer. Doesn't use any shortcuts, for even every-day operations (like copy-paste).
 
Geekness:
Beginner
Description:
Puts effort into using some shortcuts at IDE and OS level.
Geekness:
Practicioner
Description:
Uses some shortcuts and methods (not always the shortest) to do actions in the dev environment. Typing speed is okay.
Geekness:
Experienced
Description:
Uses most of the shortcuts and tools built into the developer environment.
Geekness:
Professional
Description:
Uses the computer as a real programmer. It's great to see how much the IDE can help. Types really fast.
Geekness:
Senior
Description:
Uses the computer like a well fitting exoskeleton. It's kinda hard to follow the work with a human mind. Writes custom macros for IDEs.