Graduate Engineer

Learning & Growth

• Approaches every task as an opportunity to learn, not just to complete.
• Asks questions without hesitation and seeks to understand the "why" behind decisions.
• Applies feedback consistently and tracks personal development over time.
• Reads widely - documentation, code, articles - to build context and understanding.
• Reflects regularly on their own progress, identifying gaps and discussing them with their TTL or mentor.
• Shows willingness to learn from mistakes without defensiveness, treating them as development opportunities.
• Seeks out pairing and shadowing opportunities proactively rather than waiting to be invited.

Delivery

• Completes assigned tasks reliably within agreed timeframes with close guidance.
• Raises blockers early rather than pushing through silently.
• Takes quality seriously from the start, even on small pieces of work.
• Follows the agreed development workflow - branching, committing, opening PRs - consistently and correctly.
• Responds to review feedback promptly and addresses it thoroughly before requesting re-review.
• Keeps task status up to date in the team's tracking tools so the team has an accurate picture of progress.
• Makes incremental, reviewable commits with clear messages that describe what changed and why.

Quality & Craft

• Writes code that is readable and follows the team's style conventions with support from a senior engineer.
• Begins writing basic unit tests for their own changes, guided by a more experienced colleague.
• Reads and understands test coverage for the areas they are working in, asking questions about gaps.
• Follows the team's definition of done and checks their own work against it before requesting review.
• Avoids submitting code with known issues or unresolved TODO comments without prior discussion.
• Develops an awareness of technical debt and flags it when encountered, even if not yet expected to resolve it.
• Learns what good code review feedback looks like by observing and receiving it consistently.

Communication

• Provides clear, concise updates in stand-ups - what they worked on, what they plan to do, what is blocking them.
• Writes commit messages and PR descriptions that give reviewers enough context to understand the changes.
• Asks questions in writing when appropriate so that the answer can benefit the wider team.
• Communicates learning needs honestly with their TTL and mentor.
• Responds to messages and review comments promptly during working hours.
• Summarises their understanding when given verbal instructions to confirm correct interpretation.
• Escalates concerns about timelines or quality to their TTL early rather than hoping the problem resolves itself.

Collaboration

• Contributes positively to team energy and culture.
• Communicates openly and asks for help when needed.
• Respects the expertise of more experienced colleagues while building their own voice.
• Participates actively in stand-ups, retrospectives, planning sessions, and team discussions.
• Pairs with senior engineers willingly and engages during sessions rather than passively observing.
• Offers help to teammates when capacity allows, even in small ways such as checking a PR or sharing something recently learned.
• Respects agreed team norms around working hours, communication channels, and collaboration tools.

Ownership

• Takes responsibility for completing tasks they have committed to, rather than waiting to be chased.
• Follows through on review actions and does not consider a task done until it has met all agreed criteria.
• Flags uncertainty about a requirement or approach rather than making an assumption that leads to rework.
• Keeps their own task board updated so the team always has an accurate picture of progress.
• Owns their learning plan and does not wait for opportunities to be handed to them.
• Acknowledges mistakes openly, explains what happened, and focuses on what they will do differently next time.
• Takes the initiative to read relevant documentation before asking a question that is already answered.

Technical Foundation

• Develops working knowledge of the team's primary programming language and applies it in delivered tasks.
• Uses Git competently for branching, committing, and raising pull requests as part of everyday work.
• Reads and navigates the existing codebase to understand context before making changes.
• Begins to understand the team's testing approach and why automated tests matter.
• Learns the team's deployment and release process at a conceptual level.
• Builds familiarity with the team's development environment, tooling, and local setup.
• Understands the basic architecture of the system they are working in well enough to make safe, localised changes.