What We Expect From Software Developers on Each Level
I described in a separate post details about the process we’ve been doing recently in our engineering department, where we started working with levels for our engineers and QA. After discussions in our tech directors forum and review of the expectations by every member of our department, we ended up with the below list.
I hope it can help you, junior developers who want to understand better if “you’re there yet”, or managers who want to get inspiration.
Every level’s expectations include the expectations from levels below it. We expect people to meet about 80% of the expectations per level, as opposed to all of them, because people are different.
We added tags to expectations: requirement, level-up opportunity, etc. In the below text, everything is labeled ‘required’ unless mentioned otherwise. The most interesting tags are Baseline and Level Up Condition.
- 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 (Level up opportunity).
- Be able to reproduce bugs and to fix UI layout issues.
- Learn and practice clean code (Level up opportunity).
- Manually test the flows / bug-fixes created by them (to have full accountability for commits).
- Given heavy mentoring, execute tasks outside of their level (Level up opportunity).
- Understand the CI/CD tools and flows, and with mentoring can deploy to production.
- Contribute to code documentation and readability (by renaming or adding comments in unclear places. Level up opportunity).
- Be able to improve after feedback (given constructive and specific feedback. Baseline).
- Be able to ask for help when needed — use the team to deliver.
- Review and understand code reviews of others.
- Can plan and take responsibility for their own time.
- Be able to solve a bug from production (reproduce from report, investigate, fix and deploy).
- Write unit tests, given the framework is in place (Level up opportunity).
- 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 (Level up opportunity).
- 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 me to fulfil (e.g. 1.5 days). Not including breaking a story to tasks. The precision isn’t important, rather engaging in estimating and improving over time.
- Engage with their personal growth plan (identify with help what are areas of improvements and work towards it).
- Assists in setting up CI/CD (Level up opportunity).
- Pair or Mob with more experienced colleagues (Level up opportunity).
- Be able to maintain (as a single developer, but with mentoring) a small project after it’s been released to production (Level up opportunity).
- Participate in the documentation of the solution, such as repository README, process descriptions and system descriptions.
- Perform code review — according to the team’s review guidelines.
- Be proactive in making sure they get enough code reviews.
- Can deal with reasonable context switches.
- Implement a story (incl. breaking the story to tasks and estimate).
- Has good grasp of implications of architecture decisions (Level up opportunity).
- Complete devOps tasks related to their features: adding monitors, modifying CI/CD pipelines, 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 (Level up opportunity).
- Be a source of information to the team in (at least) one subject (one library, one practice, etc).
- Setup tests framework and write tests with little to no mentoring.
- Lead Pair or Mob programming sessions with more junior developers (I disagree with this one being in a mid level, I think it should be in senior. Level up opportunity).
- Coaching of 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.
- Can design a software solution from scratch within their field.
- Can implement CI/CD Tooling incl. selection and setup of infrastructure.
- Be accountable for readability, scalability and maintainability for a platform in a project.
- Choose a stack for a project after research and consideration with their team.
- Mentoring mid and junior developers.
- Tests: choose stack, decide what should be tested.
- 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.
- Be active in the API specs (contracts) creation (both ends).
- 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 (level up opportunity).
- 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.
Tech Lead (IC path)
Our tech leads are 80% senior developers in their projects, and 20% responsible on advancing the technologies they work with. We will have tech leads per technology, for example: Android Lead.
- Giving internal educational and inspirational talks.
- Advising on growth plans.
- Be involved in the community of their domains in Stockholm/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 used areas.
- Ability to understand clients business and factor this understanding into solutions.
- Part of defining the dept. strategy — culture, stack, etc.
- Create trust relationship with the client and cultivate a close relationship with tech people of the client.
- Remove technology blockers from the team.
- Identify cases of being bottle necks and change the structure to fix them.
- Mentor team members according to their growth plan.
- Work on the team dynamic to maximise abilities, growth, collaboration and innovation.
- 1:1s with tech team members.
- Work with design and biz directors to achieve the goals for that studio.
- Resolve conflicts in the team.
- Strategic advisory towards the client.
- Maintain a constructive feedback culture.
- Support in building a culture of a community.
Every organisation has different needs, and the fact that these are ours doesn’t mean that they need to be adopted exactly by another organisation — on the contrary. I highly recommend reading about the process of how we introduced them.