This project is currently in BETA, it's ready to use, but wording and examples may still change.

Junior to Mid

Mid level engineers should be proficient in the technical systems that they are working on. They should be aware and guided by the wider context of their work. They should take responsibility for their work and own their personal development. They should be working as part of a team to achieve the shared goals of the team.

The competencies for Junior to Mid are outlined below. Before reviewing them, it is helpful to review how to use these competencies.

Area Competency
Technical

Is responsible for and maintains their computer and local development environment, e.g.

  • Keeps local tools up to date
  • Follows instructions to get software projects running locally
Technical

Uses version control to manage development workflow, e.g.

  • Git specific example: clone, branch, add, commit, push, rebase
Technical

Uses code to make something, e.g.

  • Takes a feature from their team backlog and writes the code for that feature
  • Automates a regular task using Python
  • Writes a CloudFormation template
Technical

Writes automated unit and end to end tests for features

Technical

Fixes or updates tests when changing existing code

Technical

Reuses existing code, e.g.

  • Uses a python package in project
  • Uses a node package in project
  • Integrates with proprietary software packages
  • Uses Origami
Technical

Maintains the security of the systems they work on, e.g.

  • Fixes vulnerabilities in dependencies raised by Snyk
  • Fixes vulnerabilities raised by the cyber security team
  • Doesn't introduce vulnerabilities outlined in the Open Web Application Security Project (OWASP) top 10

Supporting URLs:

Technical

Regularly and independently debugs and fixes bugs in their own code, e.g.

  • Fixes broken tests caused by changes in their code
  • Uses logging or a debugger to find the root cause when a new feature is not working as expected
Technical

Gets involved in fixing live incidents in production, e.g.

  • Notices that an AWS region is down so fails over to another region
  • Responds to alerts for services in production by investigating errors and beginning remedial action
  • Works as home teams' "ops cop", liaising with Operations and Reliability to restore a service
Technical

Uses continuous delivery or build pipelines for automation, e.g.

  • Sees their build is failing and finds out why using the CircleCI or Jenkins interface
  • Restarts broken builds
  • Makes config changes in CircleCI
  • Adds a build status badge to their project
  • Promotes an app from staging to production in Heroku
Technical

Uses monitoring (but doesn't necessarily implement monitoring), e.g.

  • Pingdom, grafana
Technical

Makes pragmatic decisions about technical trade-offs within their own code, e.g.

  • Weighs up the benefits of making code more abstract vs specific
  • Reasons about making an API call from the client or from the server - it's easier from the client but core experience will be worse
Communication

Maintains documentation on the systems they work on, making it easy for future engineers to interact with systems and code, e.g.

  • Writes READMEs with the appropriate level of detail for getting the project set up
  • Documents common issues with the codebase in a troubleshooting section in the README
  • Finds some documentation they are reading is out of date so opens a Pull Request to improve it
  • Writes good commit messages that explain why a change was made
  • Puts line comments around any 'magic' bits of code
  • Writes and updates runbooks for services they work on
Communication

Provides feedback on peer’s work, e.g.

  • Reviews pull requests and gives actionable empathetic feedback
  • Recognises when a more senior colleague has not given enough detail in an explanation, and asks for clarification
  • Gives realtime feedback in mob programming sessions
Communication

Writes clear tickets, issues and bug reports that contain the necessary amount of detail to be picked up by other engineers, e.g.

  • Adds links to the pages that are affected by a bug
  • Writes steps to reproduce an issue that they've found
  • Adds screenshots to a ticket to help explain a display bug
Communication

Receives feedback and acts upon it, e.g.

  • Implements requested changes on a pull request
  • Responds to comments on a Google document
  • Receives feedback from the team that sometimes they don't seem well prepared for morning stand-ups, so takes 5 minutes before stand-ups to gather thoughts about what the status of their work is
Communication

Regularly gives timely actionable feedback to colleagues, e.g.

  • Emails positive feedback to a colleague's line manager, after the colleague was especially helpful.
  • Notices that someone in the team has invited everyone to a meeting without an agenda. Asks them to add one so people know what the meeting is for and can prepare properly.
Communication

Presents their own work clearly to a product owner or tech lead, e.g.

  • Talks about their progress in standup without going into deep technical detail
  • Explains their approach to a technical problem to their tech lead
  • Gives a live demo of a feature that they worked on to their team
Delivery

Works on the most important task, e.g.

  • Picks the story from the top of a prioritised backlog rather than picking the one that most interests them
  • Creates tickets to capture non-trivial tech debt, rather than getting side-tracked by things not needed to complete the current task
Delivery

Uses user research or data to inform decisions, e.g.

  • Attends customer based user research for a feature being worked on
  • Sets up a testing session with peers for a new bit of tooling
  • Finds a common pain point among teammates and proposes/builds a solution for it
Delivery

Leads on getting well defined tasks from backlog to production, e.g.

  • Turns a user story into a technical implementation in production
  • Raises blockers in timely way
Delivery

Regularly collaborates with team members from other disciplines to deliver features, e.g.

  • Pairs with the designer who worked on visuals or wire-frames for a feature
  • Sits with their product owner to discuss some edge-cases in a feature
  • Helps to debug a cross-browser issue with a tester
Delivery

Regularly contributes openly to team meetings and encourages others to do so

Delivery

Regularly communicates the status of work

Delivery

Asks for help or clarification on tasks when required

Delivery

Participates in delivery process, e.g.

  • Moves tickets to done column when they are complete
  • Goes to stand-ups and communicates progress
Leadership

Knows who their project's stakeholders are

Leadership

Acts with integrity, honesty and accountability

Leadership

Positively contributes to an inclusive team culture, e.g.

  • Reminds others that team members may have child care duties
  • Draws people working remotely into planning conversations
  • Tactfully calls out exclusive or alienating behaviours from others
  • Organises a leaving collection for a colleague
  • Documents team norms to help new starters
  • Checks in with team members who appear stressed
Leadership

Shares knowledge with peers informally, e.g.

  • Pairs on a feature with a more junior colleague
  • Helps onboard a new hire, acting as their go-to person for questions
  • Comes back from a conference and shares their learnings with others
Leadership

Has worked with teams outside of their home group (where home group will be one of Customer Products, FT Core, Internal Products, Operations and Reliability, Enterprise Services and Security, FT Group Products or FT Labs), e.g.

  • Based in Customer Products but collaborated with developers from FT Core to build a new API endpoint for content
  • Has done a bootcamp with another group
  • Had done a secondment to Operations and Reliability
  • Works in the Interactive Graphics team and collaborates with someone from Editorial on a project
  • Works in Internal Products and collaborates with the Origami team on a new feature in a component
Leadership

Takes ownership of their personal development, e.g.

  • Sees some code that they don't understand, and researches how it works
  • Proactively learns how to use a new tool/language feature
  • Reads blog posts about technology
  • Studies for and attains a technical certification
  • Finds a training course and takes it
  • Attends meet-ups or conferences