Category Jr. Developer Mid-Level Developer Sr. Developer
Category Jr. Developer Mid-Level Developer Sr. Developer
Data Structures and Algorithms Knows the practical differences between Arrays, Linked Lists, Dictionaries, etc.

Has used libraries for sorting, searching, and data structure traversal / retrieval
Knows the space and time tradeoffs between data structures

Has implemented tree search algorithms and fully understands sorting and searching algorithms

Understands combinatorics   and graph theory
Has deep knowledge of data structures, understands hashing principles, may have worked with advanced data structures like B-trees

Has implemented dynamic programming solutions and graph algorithms
Code (Generic) Has programmed for school projects, possibly a couple of side projects

Probably knows 1 language well, 2-3 others weakly
Has contributed to open source / shared code / helped to answer questions on forums such as Stackoverflow or Quora

May have attended events such as Railsbridge, PyCon, RailsConf, etc.

Probably knows 2-3 languages well, another 2-3 weakly
Contributes actively to open-source, probably has multiple public repositories

Probably has a deep understanding of 2-3 languages, and knows another 5-10 weakly
Formalized Knowledge Understands topics such as:
  • Discrete math (first order logic, graph theory, combinatorics)
  • Object-oriented design patterns
  • Principles of object-orientation
  • Big O notation

Has read books like:
"Design Patterns: Elements of Reusable Object-Oriented Software"
"Topics in Discrete Mathematics"
Has an understanding of:
  • Programming philosophy
  • Efficiency
  • History
  • Programming best practices

Has read books like:
"The Pragmatic Programmer"
"Programming Pearls"
Has a deep understanding of:
  • Software architectures and how they are applied in context
  • Best practices in more than one langauge

Has read books like:
"Software Architecture: Foundations, Theory, and Practice"

Actively reads blogs regarding best practices

Has read and understands advanced topics such as antipatterns
(BA)SH Has used term, is familiar with directory traversal, file modification, SSH / SCP / SFTP Comfortable with BASH scripting and has used it for automation of simple tasks

Understands login shell vs. cronshell

Has a cursory knowledge of Linux binaries (e.g., sed, awk)

Uses package management system
Expert in BASH scripting, comfortable using it to tackle any suitable task (i.e., those not requiring math)

Uses aliases for common tasks

Deep understanding of package management system, alternatives, and pathing
Version Control Has used Git and/or SVN

Understands branching and merging strategies as laid out by senior developers
Uses Git / SVN, has created and managed one or more repositories Understands full engineering process, including branching, squashing, and merging strategies
Testing Writes tests with their code, as described by associated ticket Has written positive and negative test cases that creatively cover the space of possibilities

Understands testing logic and updates code to make testing easier through the use of stubbing / patching
Writes code in a TDD manner, setting up testing locally and obtaining a high level of coverage (for at least critical components)

Understands fixtures, blueprints / mocks, etc., in different frameworks (e.g. Rspec vs UnitTest, FactoryGirl vs Mock)
Code Design Hasn't architected code before, but actively learns about how their code fits into the larger scope of the project Has architected components before with the approval of an architect

Able to design components with interconnections both on and off-platform

Has created communication, sequence, and ER diagrams

Understands how the moving pieces of the architecture fit together at a high level (not just their work)
Has architected whole projects according to best practices

Full understanding of the interconnection of components and systems

Able to effectively communicate designs through diagrams and written language
System Design Hasn't done system-level design before Understands how code will interact with a system, is able to decouple code dependencies to avoid issues with build and deploys Has full understanding of how systems will interact, includes this as part of architecture of solution

Able to effectively communicate final architecture including system components with specific examples
Technical Specifications Has written an architecture document describing the proposed project Has written detailed architecture documentation in design and mapped it to the architecture as-implemented to identify gaps and highlight changes to stakeholders Able to communicate effectively both technically, creating specifications that are detailed for engineers, while working with business and other stakeholders to explain problem resolution
Code Decomposition / Organization Able to break down solvable problems into code with multiple functions

Isn't aware of common code smells

Actively attempts to DRY up code and write reusable methods

Implements code according to the style guide(s) laid out be senior developers
Creates reusable functions, objects, and libraries

Organizes code effectively and clearly. With methods grouped logically by functionality and/or accessibility

Structure of code matches expectations related to design and is clearly labeled

Class, method, and variable names are clear and in the accepted standard
Creates code that is easily tested and broken down into small components to achieve high readability and low (or no) code smells (e.g., duplication, complexity)

Has a strong understanding of licensing

Has a strong understanding of coding style and helps to maintain this across the team

Helps to write / augment style guides for readability / clarity and reduce code smells
Defensive Programming / Error Handling Doesn't have a strong understanding of defensive programming and/or error handling Checks all arguments and return values, ensures that critical arguments meet requirements

Catches appropriate errors, and plans for unexpected errors, cleaning up connections / objects/ memory when they occur
Simulates many faults when doing testing, understands where components can break as well as their interdependencies

Understands the cost / benefit tradeoff when using exceptions and uses this understanding to weigh the relative benefit of testing for failure conditions vs. catching exceptions
APIs / Frameworks Has used APIs / frameworks Has a deep knowledge of RESTful APIs, having used many

Has a deep knowledge of at least one framework (e.g., Django, Rails, J2EE, etc.)
Has designed at least one API (complete with versioning / deprecation plan)

Has written a framework, or libraries for a framework
Relational Database Has used SQL SELECT, JOIN statements

Leverages knowledge of more senior developers when writing queries, verifying their cost before addition to production code
Has implemented databases according to best practices, can map these choices in an ER diagram

Understands one SQL implementation well (e.g., MySQL, PostgreSQL, DB2, Oracle, etc.)

Understands how to analyze query effectiveness using analyze / explain, as well as tools for understanding such an analysis (e.g., https://explain.depesz.com for PSQL)

Understands foreign key relations and indices

Understands the limitations of ORM and uses caution when relying on ORM

Is aware of the normal forms (e.g., BCNF, 4th normal form) and can describe them in plain English
Understands multiple SQL implementations well

Understands how to optimize queries for various contexts

Understands how DB use will interact with the system

Understands partitioning, sharding, and other advanced topics
NoSQL Has no NoSQL experience / doesn't understand the NoSQL use-case Has worked with NoSQL (e.g., Redis, Mongo, Hadoop, Cassandra)

Can describe NoSQL at a high level.

Understands when to use NoSQL vs. relational DBs.
Has used various types of NoSQL.

Understands their underlying distribution / replication / lookup mechanisms.
Process Participates in planning / prioritization and wrap-ups / reviews Helps to enforce good process amongst more jr. developers

Has good estimation abilities during planning / prioritization

Identifies areas where process can be improved and escalates this to management / senior engineers
Helps to develop good process, improving process where it already exists or implementing new process where it does not
Written and Oral Communication Communicates effectively with peers Communicates effectively with peers and business stakeholders

Communicates up / escalates when needed

Can effectively describe technical problems in plain English
Communicates effectively at all levels

Prompts the audience to understand level of understanding discreetly, adapts to the situation as needed
Industry-Specific Knowledge Knows what the business does (revenue streams) Has domain-specific knowledge (in this case ad-tech), e.g., ad tags, universal site tags, exchanges, DSPs, DMPs

Knows about industry topics such as fraud, viewability, targeting, and how they related to different advertising channels
Understands how the ecosystem fits together

Deep understanding of industry topics, e.g. how the various types of fraud are actually committed and how they are typically combatted
Agility Requires multiple days of investigation before implementation begins for complex tasks. E.g., implementing something in a new framework.

Requires several further days for implementation.

Requires several further days for incremental improvements.
Requires 1-2 days of investigation before implementation begins for complex tasks. E.g., implementing something in a new framework.

Requires multiple days days for implementation.

Requires multiple further days for incremental improvements.
Requires <1 day of investigation before implementation begins for complex tasks. E.g., implementing something in a new framework.

Requires multiple days days for implementation.

Requires few days for incremental improvements.
Adaptability Works hand-in-hand with a subject-matter expert on new tasks.

Able to take previous learnings and adapt them to new situations.
Able to understand new and complex tasks and research each component to come up with solutions (to be approved by a subject-matter expert).

Can easily pick up new frameworks for a language in which they are strong.
Able to drop into new frameworks and languages in familiar paradigms.
Thought Leadership N/A Investigates upcoming technologies

Shows an interest outside of work in software development and technology

Identifies problems that may effect the organization and escalates them to management / senior engineers
Makes technology recommendations to the organization

Creates trainings and presentations for internal and potential technologies

Acts as a subject-matter-expert, writing on a subject or subjects of expertise (being published somewhere is preferable)
Leadership N/A Works with jr. developers to help them to understand difficult topics

Is able to guide jr. developers with respect to problem size estimation
Works with jr. and mid-level engineers to help them to understand complex topics, architecture, and provides problem-solving strategies and learning opportunities

Is able to assign work based on skill-level
Interpersonal Skills Works well with others

Takes direction from senior engineers and management

Asks questions respectfully

Shares opinion openly and honestly, but respectfully

Escalates interpersonal issues to leadership for aid with mediation
Works to clarify needs from management and business stakeholders effectively

Disagreement with colleagues are managed with respect and purely on the merits of the issue

Actively builds relationships across the organization
Aids in conflict resolution using analysis and information vs. opinion

Helps to resolve conflict in a timely manner

Executes decisions made by the team and/or management with a positive attitude, regardless of personal opinion

Independently resolves conflict

Manages expectations with stakeholders, identifying and informing key stakeholders at the right times

Asking the right questions of stakeholders to ensure successful execution of projects
Self-Awareness Internalizes feedback.

Can take constructive criticism and use it to improve.


Understands shortcomings and actively seeks to improve with the help of manager / senior engineers.

Actively solicits feedback both professionally and interpersonally to improve skills.
Actively and quickly course-corrects in response to negative feedback (percieved or actual).

Understands short-comings and self-improves through individual learning, coursework, or otherwise.
Career Ownership Self-motivated

Takes an active part in their career path, asking questions and taking guidance from management / senior engineers
Defines their own quarterly goals / MBOs

Takes accountability for delivery and communication of their projects and/or components
Actively learns new skills, languages, and tools to enhance their technical and business acumen

Takes accountability for delivery and communication of cross-functional projects (even when dependent on other resources for execution)

Makes plans for development and executes effectively
Problem Ownership Tasks are assigned by manager / team lead.

Completes tasks to the best of their ability.

Requires help from subject-matter experts to overcome obstacles encountered during delivery.

Delivers tasks on time.
Takes accountability for problems / tasks.

Identifies solutions and their timelines for problem resolution.

Raises issues early related to the issue and /or delivery and communicates them to tech lead and / or management

Takes responsibility for failings, perceived or real.

Identifies more than one way to resolve a problem, requires the help of a subject-matter expert to make decisions.
Organizes tasks to buffer for potential issues, setting clear expectations with consumers / management.

Course corrects quickly when problems arise, taking responsibility and working towards a resolution without hesitation.

Identifies more than one way to solve a problem and is able to communicate the cost/benefits of each one and why they chose one solution over another.