Intermediate Software Engineer

Learning & Growth

• Continuously develops technical depth in the team's core languages, frameworks, and tooling.
• Seeks stretch opportunities - taking on problems slightly beyond current comfort to accelerate growth.
• Reflects on delivery outcomes - what went well, what could be improved - and applies those lessons to subsequent work.
• Engages with the broader engineering community through reading, conferences, or external communities of practice.
• Identifies patterns in the feedback they receive and works systematically to address underlying weaknesses.
• Discusses career development goals honestly with their TTL, including aspirations and the gaps to address.
• Learns from colleagues across disciplines - product, quality, operations - not only from other engineers.

Delivery

• Delivers consistently without requiring close oversight, managing scope and quality end-to-end.
• Identifies risks and ambiguities early and resolves them proactively, before they become blockers.
• Takes responsibility for the quality of their output, not just the completion of tasks.
• Manages sprint commitments accurately, re-forecasting and communicating clearly when circumstances change.
• Owns the deployment of their features through the release pipeline, resolving issues as they arise.
• Coordinates dependencies with other teams or components early, avoiding late-stage integration surprises.
• Verifies delivered features in production or staging environments, not only in local or CI contexts.

Quality & Craft

• Writes high-quality, well-tested code that serves as a positive reference for the team.
• Applies test-driven development or a strong testing discipline consistently across all delivered work.
• Conducts thorough, constructive code reviews that improve both code quality and reviewer understanding.
• Identifies and addresses technical debt within their area of work, not only when directed to do so.
• Considers non-functional requirements - performance, security, maintainability - as part of feature design.
• Raises quality concerns before merging rather than filing post-release issues.
• Sets a visible quality standard through their own work that encourages others to match it.

Communication

• Communicates technical decisions and trade-offs clearly to both engineers and non-technical stakeholders.
• Writes design documents and ADRs that are structured, well-reasoned, and accessible to the team.
• Provides specific, actionable code review feedback that explains the reasoning, not just the correction.
• Gives and receives feedback in a direct, respectful, and constructive manner.
• Runs or contributes meaningfully to technical discussions without dominating or dismissing others.
• Updates tickets and PRs with sufficient context that the team can follow the decision trail without asking.
• Flags delivery risks to their TTL early, with a clear explanation and a proposed path forward.

Collaboration

• Actively improves the team around them, not just their own contribution.
• Gives feedback in code review that is specific, constructive, and kind, and receives feedback the same way.
• Works across disciplines - with product managers, quality engineers, and operations colleagues - without friction.
• Contributes to retrospectives with specific, thoughtful observations and follows through on agreed actions.
• Supports graduate and junior engineers in ceremonies and pairing sessions, creating space for them to contribute.
• Raises process or tooling improvements with clear reasoning rather than just raising complaints.
• Builds trust through consistent, reliable behaviour that colleagues can depend on.

Ownership

• Takes full ownership of features from design through to live, including post-deployment verification.
• Makes sound technical decisions within their domain without needing to escalate every choice.
• Knows when a decision is within their remit and when to involve a senior engineer or architect.
• Balances pragmatism with quality - delivering working software without creating unnecessary debt.
• Proactively identifies and addresses risks rather than waiting to be asked.
• Takes initiative to improve things they notice are broken or inefficient, not only what is assigned to them.
• Holds themselves accountable to the commitments they make in planning, and communicates honestly when those change.

Technical Foundation

• Applies strong working knowledge of the team's primary languages, frameworks, and tooling across complex features.
• Designs components and feature-level solutions with sound structure and clear separation of concerns.
• Writes and maintains comprehensive automated test suites as a standard part of delivery.
• Manages configuration and environment-specific concerns confidently across the delivery pipeline.
• Understands and operates the team's release and deployment processes, resolving pipeline failures independently.
• Contributes to systems integration work, understanding how components interact and where failure modes arise.
• Contributes meaningfully to architectural discussions at the service or component level, reasoning about trade-offs with evidence.

Knowledge Sharing

• Shares knowledge generously and without gatekeeping, through pairing, documentation, and team discussion.
• Mentors graduate and junior engineers actively, providing structured feedback and creating learning opportunities.
• Contributes to internal documentation - runbooks, ADRs, onboarding guides - as a regular part of their work.
• Facilitates or contributes to team learning sessions, internal demos, or guild discussions.
• Helps colleagues understand the rationale behind technical decisions, not just the outcome.
• Identifies knowledge gaps in the team and takes steps to address them through structured sharing.
• Ensures the knowledge required to operate, support, or extend their work is captured and accessible before handover.