Software Engineer Job Description Template

Backend engineering ownership · 22%
The role is mid-level and must deliver well-defined backend work independently, from design through release. Evaluated in Round 1.

• Weak: Completes assigned tasks but needs repeated guidance to design solutions, handle edge cases, or finalize implementation.
• Meets the bar: Independently designs and implements solutions for well-defined backend work and handles expected edge cases.
• Strong: Proactively refines requirements, anticipates edge cases, and delivers robust implementations that integrate cleanly with existing systems.

SQL and data modeling · 18%
Backend changes frequently depend on correct schema design and efficient querying to meet performance and correctness needs. Evaluated in Round 1.

• Weak: Writes queries that are correct but inefficient or struggles to reason about indexes and query plans.
• Meets the bar: Designs workable schemas and writes queries with clear performance considerations (filters, joins, indexes).
• Strong: Improves data access patterns with measurable performance gains and prevents correctness issues (e.g., duplicates, inconsistent reads).

Production debugging and observability · 18%
The engineer must be able to diagnose and fix production problems using real operational signals. Evaluated in Round 2.

• Weak: Troubleshoots slowly, has difficulty correlating symptoms to root cause, or can’t point to signals used.
• Meets the bar: Uses logs/metrics/traces to form hypotheses, isolate the root cause, and validate the fix.
• Strong: Rapidly identifies root causes, improves observability for recurrence prevention, and documents learnings.

Automated testing discipline · 16%
Strong testing practices reduce regressions and support safe iteration on production systems. Evaluated in Round 2.

• Weak: Adds limited tests or tests that don’t meaningfully validate behavior; relies on manual verification.
• Meets the bar: Implements unit/integration tests that cover core behavior and key edge cases for the change.
• Strong: Builds a test strategy that reliably catches regressions, including failure modes and contract-level checks.

API design and integration · 10%
Correct interface design and integration reduce downstream bugs and make features easier to use and maintain. Evaluated in Round 3.

• Weak: Creates interfaces that are inconsistent, hard to consume, or misses contract considerations (status codes, schemas, versioning).
• Meets the bar: Designs clear service interfaces (e.g., REST endpoints) with consistent contracts and error handling.
• Strong: Designs APIs that support backward compatibility, clear contracts, and predictable client behavior.

Collaborative engineering habits · 10%
Code review and cross-functional collaboration are essential to ship changes safely and improve team standards. Evaluated in Round 3.

• Weak: Provides minimal context in reviews or struggles to incorporate feedback into implementation.
• Meets the bar: Communicates clearly in reviews, responds constructively to feedback, and documents decisions appropriately.
• Strong: Leads improvements in team processes, helps others unblock, and elevates code quality through thoughtful collaboration.

Security mindset · 6%
Secure API patterns and authentication/authorization awareness prevent common vulnerabilities and incidents. Evaluated in Round 3.

• Weak: Overlooks authentication/authorization boundaries or doesn’t consider common security failure modes.
• Meets the bar: Implements/uses secure patterns for authorization and avoids obvious security pitfalls (input validation, least privilege).
• Strong: Anticipates abuse cases, validates authorization rigorously, and advocates for secure-by-design changes.