We’re always looking for amazing people to join our growing team. For a full readout of open positions and links to apply, visit our careers page on the main company website.

As you can read about in one of our blog posts, we do hiring a little bit differently — for the better. We’re working to build a team that’s diverse along all axes, which begins with a process that actually cares about your experience and focuses on what you can do, not how you present yourself.

Where you can go

We’re planning for the future, and that includes giving people a sense of how far they can go. We’re also very cognizant that many people, especially on the technology side, are more interested in remaining an individual contributor — focusing more on coding and building software day to day — than moving into a leadership role. It’s also important to us that we support fairness by giving people a clearer picture of exactly what they need to do to move up.

Everyone in the engineering organization uses this system to figure out where they are and where they want to go next. It goes without saying that for people in more specific roles, you might swap in “site reliability engineer” or “data scientist” for “software engineer.”

Finally, we know this plan is a work in progress. We think we’re on the right path, but we know there will be some bumps along the road.

Individual Track Leadership Track
Junior Software Engineer Individual contributor
(Full) Software Engineer Individual contributor
Senior Software Engineer Junior Team Lead
Junior Staff Software Engineer Team Lead
Staff Software Engineer Director
Principal Software Engineer VP
Chair Software Engineer SVP

Framework

For all roles, we center our set of criteria at a given level based on three core ideas. As you advance, we think you should be better at mastery (how well you can execute), collaboration (after all, we need to work together), and impact (how much what you do helps the broader ecosystem).

Timelines

We want to drive people to improve with a balance against the fact not everyone wants to be a master of the universe — and that’s fine! For that reason, we expect people to achieve a certain level within some (we think) reasonable time frames.

  • Junior to Full: 6-12 months
  • Full to Senior: 1-2 years
  • Senior to Junior Staff or Team Lead: 1-3 years

Once you’ve achieved the Junior Staff level or become a team lead, you’re still welcome to move up, but you don’t have to. By that point, you should be senior enough that you’re a “net contributor” from a leadership perspective. More people are looking to you than you are looking to other people.

As a rule, getting to the next level will get about an order of magnitude harder at every stage. In other words, it’s relatively easy to move from being a Junior Software Engineer to the Full level. It will be much harder to move from the Junior Staff to the Staff level.

Individual Track

Junior Software Engineer

  • Mastery
    • Writes code that is basically functional, but requires detailed, direct input and feedback from a more senior engineer before it will work (e.g., will often fail to build due to a Semgrep failure)
    • Code lacks elegance and efficient design
    • Requires direct input and feedback on issues like test writing
  • Collaboration
    • Requires frequent monitoring and reminders to fully internalize priorities and provide updates to other team members on completion times
    • Often requires consulting another team member to figure out who the right person to ask is about a particular question
    • Passive hiring participant (e.g., observer on interviews)
  • Impact
    • Works only on very small, narrowly-scoped features
    • Examples: Converting a feature to being controllable with a LaunchDarkly flag, fixing a bug in the pre-storage validation code for an API

Software Engineer

  • Mastery
    • Writes code that sometimes requires tactical line-item feedback (e.g., misnamed variables)
    • Still requires occasional nudges and nagging on issues like writing tests
    • Active interviewer and sift question grader in our hiring process
  • Collaboration
    • Requires only occasional monitoring and reminders to fully internalize priorities and providing updates to other team members
    • Generally knows who the right person to ask is for a given question, but sometimes gets it wrong or has to ask someone more senior
    • Active hiring participant (e.g., grades sift questions and sits on interview panels)
    • Encourages other members of their team to follow good practices (e.g., reminds others to write tests)
  • Impact
    • Works on small features
    • Examples: Adding a new API route to deliver product recommendations filtered by category, fixing a bug in the code that handles price ingest

Senior Software Engineer

  • Mastery
    • Code reviews begin to open conceptual discussions (e.g., which JSON package to use)
    • Provides impactful feedback for other people’s code (e.g., catches a basic edge case)
    • Writes tests and aids deployment without being asked
    • Can customize an existing job in their functional area for a new hire
    • Can lead an interview
    • Presents at or contributes to internal mastery events (e.g., journal club, engineering blog)
  • Collaboration
    • Able to work independently with priorities and deadlines on shorter timescales (e.g., two week project)
    • Active contributor to project ideas in high-level and detailed planning
    • Knows who to ask for help, and helps teammates find that person
    • Works with team leads to think about hiring strategy
  • Impact
    • Builds out major features on their team
    • Examples: Adding a frontend component to support a new recommendations carousel, building a new API route to add a completely new search feature

Junior Staff Software Engineer

  • Mastery
    • Code reviews consistently drive within-environment conceptual discussions (e.g., which JSON package to use)
    • Provides high-impact feedback on other people’s code (e.g., order of magnitude speedup rather than avoiding one small edge case)
    • Drives active measures to improve code quality (e.g., encourages other people to use Semgrep)
    • Can write a new job from scratch in their area of expertise
    • Leads internal workshops or internal mastery events (e.g., ML summit)
  • Collaboration
    • Able to work independently with priorities and deadlines on longer timescales (e.g., two month project)
    • Collaborates with product and engineering management to self-manage projects as part of the planning process
    • Helps teammates from their and other teams as part of their project planning
    • Helps other team members in the same functional area prepare sift and interview questions for jobs
  • Impact
    • Builds out major features for their team that scale to other teams as well
    • Works on major features that are either very important to one group, or that have broad applicability
    • Examples: Rewriting a whole frontend component for your team that other teams also use, building a new utility function to make it easier to reweight recommendations by category, improving our reorder model

Staff Software Engineer

  • Mastery
    • Code reviews focus on conceptual questions (e.g., decision to use Rust versus Python)
    • Builds systems to scale up their quality (e.g., drives adoption of a tool like Semgrep) as part of their work
    • Helps contribute to hiring strategy for their functional area
    • Shows expertise in an external setting at a small scale (e.g., speaks at local Python meetup or has a few silver badges on Stack Overflow, makes a small contribution to a major open-source project)
  • Collaboration
    • Able to work independently on very long timescales (6-12 months)
    • Collaborates with company leadership on key technical features
    • Acts as a resource for technical leads across the company
    • Hosts internal events beyond their function (e.g., Tech 101)
    • Reference point of expertise for non-engineering resources (e.g., can help a sale close)
    • Maybe manages one or two other Junior Staff engineers to help execute projects
  • Impact
    • Builds out major features or systems with the express purpose of it scaling to other teams, builds features with immense complexity
    • Example: Rewriting Gluon in a different framework, switching all of our infrastructure to a different provider

Principal Software Engineer

  • Mastery
    • Code reviews focus on conceptual and architectural questions spanning multiple systems (e.g., rewrite in Erlang while combining two redundant services)
    • An internal point of reference for implementation quality
    • Key decision maker in hiring strategy in their highly-specialized area of expertise
    • Shows expertise in an external setting at a larger scale (e.g., speaks on a panel at a national conference, is a core contributor to a major open-source project)
  • Collaboration
    • Able to work independently on extremely long timescales (1 year or more)
    • Reports directly to a vice president or above
    • Reference point beyond the company
    • Maybe manages one or two other Junior Staff plus engineers to help execute projects
  • Impact
    • Builds out very complicated, major features with high-impact
    • Example: Rewriting and completely restructuring Gluon to produce a 10x cost savings and 10x speedup, paradigm-shift in one of our machine learning models

Chair Software Engineer

  • Mastery
    • Code reviews focus exclusively on fundamental questions (e.g., how to compile code in an invented Turing-complete programming language)
    • An internal point of reference even for a principal software engineer
    • Key decision maker in global technical hiring strategy
    • Shows expertise in an external setting at a global scale in the highest possible impact settings (e.g., hosts a workshop at NeurIPS, publishes a best-selling book, wins a national award)
  • Collaboration
    • Provides foundational, key knowledge unavailable from another resource to key technical team members internally
    • Maybe manages one or two other Junior Staff plus engineers to help execute projects
  • Impact
    • Builds out major features internally that have significant impact beyond the company
    • Ambassador for the company on a global scale (e.g., their impact helps the company’s credibility more than the company’s credibility helps them)
    • Example: Skunkworks project to develop the Swift programming language at Apple (Chris Lattner and a couple of other people in secret, for several years)

Leadership Track

Junior Team Lead

  • Mastery
    • Experts leading experts: contribute at the senior engineer level to projects
    • Politics: Drive new initiatives on the team level, passive participant in driving change outside your team (e.g., change the way prioritization happens on your team)
    • Teaching: Run regular one-on-one meetings and reflection meetings to improve team performance over time, act as a resource primarily to your team
    • Administration: Managing and building processes for projects on shorter timescales (e.g., one month)
    • People: Passive hiring participant, but run the logistics of a hire
  • Collaboration
    • Works with product on features, but is maybe somewhat passive
    • Helps other engineers steer projects on shorter timescales (e.g., two weeks)
    • Drives small or one-time changes on their team (e.g., asks people to attend standup at a different time, asks someone to do something once)
  • Impact
    • Manage only individual contributors
    • Team delivers small and medium-size features
    • Example: Launch revamped search algorithm (frontend plus new backend and machine learning technologies)

Team Lead

  • Mastery
    • Experts leading experts: contribute at the Junior Staff engineer level to projects
    • Politics: Drive new initiatives on the team level, active participant in driving changes outside your team (e.g., getting another team to use a new API documentation tool to help your team)
    • Teaching: Run regular team exercises, and sometimes act as a resource beyond your team
    • Administration: Managing and building processes for projects on longer timescales (3-6 months)
    • People: Active hiring participant (e.g., contribute to hiring strategy and can build a job from scratch), minimal coaching required
  • Collaboration
    • Works with product on features, and actively helps balance technical priorities against product goals
    • Helps other engineers steer projects on medium timescales (e.g., one to three months)
    • Drives large or sustained changes on their team (e.g., can assign “performance” to one engineer to self-manage, gets everyone to adopt code review)
    • Actively seeks advice on technical and management questions
    • Serves as a resource for other leaders (e.g., mentor in the Management Buddies™ program)
  • Impact
    • Manage only individual contributors, but some may include more senior engineers (i.e., Junior Staff and above)
    • Help advance members of your team up to the Staff level
    • Launch substantial new features
    • Example: Migrate our infrastructure to a new cloud provider, procuring and implementing integration platform solution

Director

  • Mastery
    • Experts leading experts: contribute at the Junior Staff engineer level to projects, preferably higher
    • Politics: Drive new initiatives at the team level for your teams and across the technical organization (e.g., getting everyone to use Semgrep)
    • Teaching: Run regular exercises across your function, including leadership exercises for the leaders under your purview
    • Administration: Managing and building processes for executing projects on long timescales (3 months or more) that span multiple teams of people (e.g., continuous deployment rollout), collaborating with other directors and upper management to set strategy over longer timescales (9 months or more; e.g., the need to stand up a data platform team)
    • People: Build and administer the execution of a hiring roadmap for your teams, manage people between the teams under your leadership and across other areas of the company
  • Collaboration
    • Facilitates longer term technical investments and projects in consultation with the product team and other engineering team leaders
    • Helps tech leads steer projects involving their whole teams or across teams
    • Drives large and sustained changes across the technical organization
    • Actively seeks advice on technical and management questions, and is a source of advice to other people
  • Impact
    • Manage other Team Leads and Junior Team Leads
    • Manage exclusively engineers at the Junior Staff level or above
    • Help advance individual contributors to the Staff level
    • Help advance individual contributors into Junior Team Lead or Team Lead roles
    • Deliver complex projects on long time scales spanning multiple teams of people
    • Example: Project to automate new client deployment setup spanning two teams