Tech Skills Rubric

There are lots of these. Here's one I've been working on for our (relatively small) team:

	Junior	Lower end of the Mid range	Higher end of the Mid range	Senior
Architecture - working with systems that involve many code bases	Can maintain individual pieces with lots of guidance	Can pick up tasks that involve several codebases at once, given guidance. Establishes or follows simple patterns (naming, style) within and across code bases.	Understands most of the big picture. Participates in architecture discussions. Uses patterns at a higher level (abstractions, interfaces), and puts logic in the right place. Can sometimes suggest and argue for ideas for arch changes...	... and those ideas are consistently right. Can dig into a system and map it out from the code alone.
Data Modelling - mapping the real world to data structures	Understands the basics of schema design, join types, etc. Can write SQL.	Can draft a (sometimes naive) data model for an anticipated feature or change, but often needs guidance.	Understands the tradeoffs in various ways of modelling data. Has a good instinct for what will be performant and understandable. Rigorous about single-source-of-truth and invalid-states-are-unrepresentable (but knows when to break those rules). Comfortable drafting schemas for even quite complex changes, though they sometimes bounce on review.	Thinks through the implications of schema design across the whole system. Careful and consistent with semantics. Can write complex SQL.
Tech Selection - figuring out the right tools for the job, and how to solve problems	Picks up the assigned tools, and uses them	Sometimes has opinions, and sometimes those opinions are right	Stays up to date, is aware of tradeoffs and higher-order effects, has opinions and can coherently debate stacks.	Looks far ahead and sets direction-of-travel for the business as a whole. Opinions are very often proven right.
Autonomy - figuring out what to do	Can take a narrow, well-specified card and execute on it.	Can identify some holes in the card. Can perform a tech breakdown, with guidance.	Finds holes in the card and gets the answers, then writes it up. Generally one-shots tech breakdowns but sometimes needs guidance. Can take a medium-sized feature through to completion.	Can take a poorly-specified, high-level business or technical goal all the way through to delivery.
Focus - not ending up in the woods	Can get stuck; needs to be polled. Scope can drift.	Doesn't get stuck in rabbitholes much; bails out and finds a new way (or calls for backup). Identifies scope creep but needs guidance to know where to cut.	Intelligently explores problems, burning out risk early, switching between breadth-first exploration and depth-first tracers as appropriate. Consistently splits scope correctly.	Also aware of ROI and higher-level effects; knows when to double down, and when to bail out
Incident response - stressful firefighting with production systems down, often in a confusing way	Invited to the incident room, but stays on mute.	Follows along, understands the problem, can execute instructions, sometimes has good ideas. Probably couldn't get prod back up by themselves.	Could potentially be first- or sole- responder; can communicate with frontline team to manage expectations and impact, can come up with workarounds, and has a good chance of fixing the problem if it's in an area they're familiar with	Knows when to take risks and when not to. Comfortable across the entire stack, and could (eventually) solve any production problem solo.
Code - writing software in a variety of languages	Can ship solid, working, tested code in at least one language/framework. PRs sometimes bounce with significant problems (but is able to address them).	Code is thought through, well-organised, and readable. Edge cases are covered. Mostly stays in familiar areas of our codebases, and/or needs onboarding help. Code is sometimes not idiomatic, or more complex than it needs to be; sometimes fixes problems by adding layers instead of removing them.	Comfortable across most of the stack and spins up quickly on the rest; could pick up almost any card. PRs are thoroughly explained, commits are well-organised and rebased (where the time/understandability tradeoff makes sense to do so). Thinks through higher-order effects like performance and impact on other systems. Avoids unnecessary complexity; PRs often reduce complexity while adding features or removing bugs.	Comfortable across our entire stack (though still may be stronger in some areas). PRs do still attract comments sometimes, but they're usually weird edge cases/specialist knowledge, or opportunities to polish, rather than structural problems or bugs. Writes code that is not only correct, it's obviously correct.
Review - reviewing and supporting other developers	Reads PRs mostly for their own education, but does sometimes catch things	Contributes to PR review lifecycle, though mostly routinely. Sometimes responds to callouts for help or opinions.	Can do in-depth PR reviews for both structure and style that often result in the committer making important changes and/or learning something	Consistently helpful, insightful, and non-obvious feedback on PRs. Can usefully support on almost any callout.
Initiative - finds work that needs doing	Still getting up to speed; executes on the 'what' but doesn't really engage with the 'why'.	Has opinions about product. Can flag potential flaws in the product design when picking up a card. Points out things that could be better, but they're not always immediately helpful (too vague, too far ahead, value-vs-time doesn't make sense, no obvious solution)	Opinions about product are often right. Creates well-organised triage cards that describe the problem, the impact/value, the effort and a suggested solution. Often right. Does drive-by fixups when it makes sense (and not when it doesn't)	Also makes high-level suggestions for both business/product and technical direction, and they're often right. Strong understanding of the overall business and the detail of what the products are meant to do, so easily spots things that are broken or need polish.
Technical Communication - written and spoken, to devs and stakeholders (soft skills not covered in this rubric, that's a whole separate skill tree)	Can have technical conversations, but they really needs to be sync (in order for the listener/reader to clarify interactively). Sometimes needs help expressing subtle details.	Clearer, more consistent and idiomatic communication (including async) but still often needs help clarifying. PRs sometimes bounce with "I don't fully understand this".	Can write up a subtle bug or design decision in a way that someone else with no context would fully understand it. Has a strong 'theory of mind' for what the likely reader/listener knows and needs to know. Spoken and written communication is consistently precise and clear. PRs are a joy to review.	Communicates efficiently across the whole team: manages airtime well, writes terse-but-precise documentation. Can code-shift to any target audience. Instinctively documents where necessary; writes RFCs.
Devops - can manage production deployments	Develops on local machine; no engagement with prod	Understands how Circle, Docker, ECR, ECS and Terraform work together in the deployment happy path. Can make minor changes to Circle/deployment processes with guidance.	Understands all of our architecture, including the more esoteric bits. Comfortable working in Terraform.	Very comfortable across the entire stack; understands likely bottlenecks, can reason about performance and cost tradeoffs, can argue for (or against!) deployment stacks. Could migrate the entire operation elsewhere, eventually, if we ever wanted to.