When evaluation time comes around, I like to send this out to the developer in advance of the meeting. Then we go through each item in the level they are at and the one above. For each item, we mark it as green, yellow, or red. Green means they have many examples of this. Yellow means they don't have a lot of examples, or they haven't been given the opportunity yet. Red means they can't demonstrate that they've do this.
By focusing on the examples, we can get away from opinions about which level the developer is on. Also, by going through the next level, we can start working on getting to that level.
Entry Level
- Be able to present and discuss what they have done, and their progress.
- Be interested in and perform learning and exploration of the tools they work with.
- Be able to reproduce bugs and to fix UI layout issues.
- Learn and practice clean code.
- Manually test the flows / bug-fixes created by them (to have full accountability for commits).
- Execute tasks outside of their level with help/guidance/mentoring.
- Understand the general tools and flows, and with guidance, can deploy to production.
- Contribute to code documentation and readability by renaming or adding comments in unclear places.
- Be able to improve after feedback given that it is constructive and specific.
- Be able to ask for help when needed — use the team to deliver.
- Review and understand code reviews of others.
- Know the basics of project management and the general terminology we use to describe our projects.
- Communicate clearly with other developers and the projects teams to give status updates, and to ask for help.
- Be able to manage a task list that spans multiple projects.
- Able to use the tools, apps, and sites that are used by our organization productively.
- Learning to estimate time to complete a task. Estimates might still vary significantly from the actual time to complete.
Associate (Junior) Level
- Can plan and take responsibility for their own time.
- Be able to solve a bug from production (reproduce from report, investigate, fix and deploy).
- Share knowledge — by writing in a channel, giving an internal talk, recording a short video, writing a blog post (Level up condition).
- Communicate about status of tasks daily.
- Attend tech meet-ups and forums.
- Understand the team members’ updates in the stand-ups and if not — follow-up offline and make sure to understand in high level.
- Understand the time expectations, raise flags about blockers or delays daily.
- Estimate tasks by time that takes to fulfill (e.g. 1.5 days). Not including breaking a story to tasks. The precision isn’t as important as engaging in estimating and improving over time. Task time estimates are reasonable and small ranges. Starting to know what you don't know.
- Engage with their personal growth plan (identify with help what are areas of improvements and work towards it).
- Be able to maintain (as a single developer, but with mentoring) a small project after it’s been released to production.
- Participate in the documentation of the solution, such as repository README, process descriptions and system descriptions.
- Is proactive in making sure they get enough code reviews.
- Knows where to get help outside of the team
- Is able to communicate with clients directly to explain technical aspects of the project.
- Review past projects to understand the code, decisions, business aspects, and the general scope.
- Avoid making the same mistake twice by keeping a log of problems and solutions (code snippets, full repos, documentation, bookmarks)
- Is proficient at using our tools.
Mid Level
- Can deal with reasonable context switches.
- Implement a feature or small project (incl. breaking the feature into tasks and estimate).
- Has good grasp of implications of architecture decisions.
- Complete DevOps tasks related to their features & projects: adding monitors, setting up VPS server, changing DB backup.
- Can execute tasks independently (incl. asking for suggestions from the team when needed).
- Be familiar with best practices, like design patterns. Know to identify them in the code and use them when writing new code.
- Assist in system architecture design.
- Be a source of information to the team in (at least) one subject (one library, one practice, etc).
- Mentoring, coaching, and guiding more junior developers.
- Can setup a development environment on their own (level up condition).
- Can refactor code modules for readability and maintainability.
- Perform code review to others.
- Understand the full lifecycle of an application.
- Contributes to project management activities, including: setting tasks, communicating with the clients, identifying and mitigating risks and issues.
- Contributes to non-development phases of projects
- Is considered to be at an expert level in at least one aspect of development
- Can see around corners. Knows what problems might occur within a project in advance.
- Expert level tool usage with some of the tools.
- Time estimates for tasks can be trusted and are fairly accurate. Able to identify risks and unknowns that will impact the time needed to complete a task.
Senior Level
- Can design a software solution from scratch within their field.
- Can select and setup of infrastructure.
- Be accountable for readability, scalability and maintainability in a project.
- Choose a stack for a project after research and consideration with their team.
- Mentoring mid and associate developers.
- Have knowledge of modern software architecture patterns and can work with them within their field.
- Can capture requirements and discuss implementation details externally and internally.
- Analysis of complex bugs within their domain.
- Can think about the software solution in general outside the scope of their tasks.
- Define code reviews standards.
- Keen to learn new technologies, follow trends and incorporate best practice (baseline).
- Will feed into the DevOps tasks and be familiar with the internal model.
- Be able to research and present a solution for an identified business or technical problem.
- Understand the whole stack used in the projects.
- Has an eye for possibilities and knows how to meet the needs of the clients.
- Accountable for the documentation of the solution, such as repository README, process descriptions and system descriptions.
- Anticipates problems and corrects the project to mitigate the issues.
- Expert level at multiple aspects of development.
- Can lead internal or dev only projects.
- Time estimates for tasks will include unknowns and still be reasonably accurate. Able to reshape the tasks to avoid difficult issues or big risks.
- Able to keep business outcomes in mind throughout the project.
Technical Lead (Senior Dev +)
Tech leads are 80% senior developers in their projects, and 20% responsible on advancing the technologies they work with. We aim to have tech leads for each technology group. For example: Front End Lead, Apps Lead, Back End Lead, DevOps Lead.
- Giving internal educational and inspirational talks.
- Advising on growth plans.
- Be involved in the community of their domains in Edmonton and online.
- Radiate knowledge internally & externally.
- Involved in interview process and sit in on interviews.
- Give directions and recommendations on integrations with client systems.
- Build own and team understanding of the client, their business model and users.
- Thinking and communicating about the challenges we will face in the next 6 to 12 months in their domain.
- Advise about reducing complexity in projects, services, systems and processes from their domain point of view.
- Design system architectures with good UX, information design, scalability and security that are cost-efficient for the client.
- Domain knowledge on platforms/frameworks.
- Be responsible for the tech radar in their domain, and communicating about it.
Tech Director (Manager path)
- Defining and follow up on our coding practices in projects.
- Define and lead solution and system architecture practices.
- Attend and contribute in external technical forums in areas important to us.
- Ability to understand clients' business and factor this understanding into solutions.
- Part of defining the department strategy — culture, stack, etc.
- Create a trust relationship with the client and cultivate a close relationship with the tech people of the client.
- Remove technology blockers from the team.
- Identify cases of bottlenecks and change the structure to fix them.
- Mentor team members according to their growth plan.
- Work on the team dynamic to maximize abilities, growth, collaboration and innovation.
- 1:1s with tech team members.
- Work with other directors to achieve the goals of our organization.
- Resolve conflicts in the team.
- Strategic advisory towards the client.
- Maintain a constructive feedback culture.
- Support in building a culture of community.