Junior Software Engineer

Learning & Growth

• Actively identifies gaps in their own knowledge and takes concrete steps to address them.
• Seeks feedback beyond what is offered and reflects on it honestly.
• Shows measurable improvement sprint over sprint in both technical skill and professional practice.
• Uses code review as a deliberate learning tool, studying the rationale behind feedback rather than just applying it.
• Reads team documentation, ADRs, and design records to build deeper understanding of the systems they work in.
• Sets personal development goals in collaboration with their TTL and revisits them regularly.
• Experiments with new approaches in safe contexts and shares what they learn with the team.

Delivery

• Delivers reliably on clearly scoped work without needing constant check-ins.
• Takes ownership of tasks from assignment through to completion, including deployment where applicable.
• Raises blockers at the right moment - after genuine effort, before significant delay.
• Manages their own sprint commitments, flagging early when scope or complexity is larger than estimated.
• Writes clear, descriptive PR descriptions that make the reviewer's job easier.
• Follows the team's branching and release workflow correctly and consistently.
• Verifies their own changes against acceptance criteria before requesting review.

Quality & Craft

• Treats testing as part of the definition of done, not an afterthought.
• Takes pride in clean, readable, maintainable code that others can work with confidently.
• Accepts feedback from code reviews with openness and applies it thoroughly.
• Writes unit and basic integration tests as a standard part of feature delivery.
• Understands and applies the team's coding conventions without needing to be reminded.
• Flags code that is fragile, confusing, or likely to cause future problems rather than leaving it silently.
• Begins to identify where test coverage is insufficient and raises it with the team.

Communication

• Communicates work, blockers, and progress clearly in both written and verbal form.
• Writes commit messages and PR descriptions with enough context for a reviewer unfamiliar with the ticket.
• Gives timely updates in stand-up without needing to be prompted.
• Asks for help at the right time - after genuine effort but before significant delay impacts the team.
• Documents decisions and approaches in tickets or PRs so the reasoning is visible to the team.
• Raises concerns about requirements, estimates, or quality with their TTL before they become blockers.
• Responds to asynchronous messages and review requests within a reasonable and predictable timeframe.

Collaboration

• Builds positive working relationships across the team, including with product and quality colleagues.
• Contributes constructively to retrospectives, offering specific observations and supporting agreed actions.
• Begins to give useful, specific feedback in code review rather than only receiving it.
• Pairs willingly with graduate engineers, sharing what they know without making it feel condescending.
• Participates in sprint ceremonies with growing confidence and contribution.
• Respects team norms and raises disagreements through appropriate channels rather than ignoring them.
• Supports a positive team environment by acknowledging others' contributions and celebrating shared wins.

Ownership

• Takes responsibility for the full lifecycle of assigned tasks, not just the coding phase.
• Does not consider work complete until it has passed review, met acceptance criteria, and been deployed where required.
• Raises risks and ambiguities proactively rather than waiting to be asked.
• Keeps task status accurate and visible in the team's tracking tools throughout the sprint.
• Follows through on commitments made in retrospectives and planning sessions.
• Acknowledges when an estimate was wrong and explains what was different, without deflecting.
• Takes initiative to investigate and resolve issues they notice, rather than assuming someone else will handle it.

Technical Foundation

• Applies solid working knowledge of the team's primary language and frameworks across delivered features.
• Uses version control workflows correctly - branching, reviewing, merging - as a matter of habit.
• Writes automated unit and basic integration tests consistently without prompting.
• Reads unfamiliar code confidently and navigates the codebase to understand dependencies before making changes.
• Understands the team's build and deployment pipeline well enough to diagnose basic failures.
• Begins to understand component-level design decisions and can reason about trade-offs at that level.
• Contributes to system integration tasks with guidance, understanding how their changes interact with adjacent components.