L1 Software Engineer

A L1 engineer is taking their first steps into the world of professional software development. They're eager to learn and apply their knowledge, often surprised by the complexity of real-world systems. Their focus is on understanding the codebase, learning team practices, and gaining confidence in their ability to contribute. They're not just coding; they're learning how their work fits into the broader product context and starting to grasp the importance of user needs.

Writes clean, maintainable code
Develops basic understanding of product goals and user needs
Understands the importance of testing and documentation
Collaborates with team members on small features or bug fixes
Seeks and incorporates feedback and guidance regularly
Develops foundational knowledge of version control and CI/CD processes

Expectations

Capability	Needs Improvement	Meets Expectations	Exceeds Expectations
Technical Expertise	Struggles to write clean, maintainable code; frequently needs significant revisions or help in structuring their code.	Writes functional code that follows basic team conventions and coding standards with support from others.	Takes initiative to independently resolve common coding issues and actively seeks to understand team standards. Consistently delivers reliable code that requires minimal revisions during review, while still operating within a supported environment.
Project Ownership	Struggles to take responsibility for assigned tasks; often misses deadlines or fails to communicate progress effectively, requiring frequent check-ins.	Executes assigned tasks, providing clear status updates and escalating blockers appropriately. Actively participates in team planning sessions and delivers commitments on schedule.	Proactively identifies and addresses potential issues within their assigned tasks while maintaining exceptional documentation and communication standards.
Business Impact	Focuses mainly on technical implementation without considering user impact; rarely asks how their work fits into the broader context.	Develops a basic understanding of product goals and user needs; implements features with guidance to ensure alignment with business objectives.	Demonstrates a good understanding of how their work contributes to product goals and proactively asks questions to align with user needs.
Communication & Collaboration	Struggles to collaborate effectively; often relies too heavily on others without contributing meaningfully to discussions.	Collaborates with other engineers; seeks input and works well in a team environment.	Works effectively with product and design teams, contributes valuable insights in team discussions.
Mentorship & Support	Does not consistently seek feedback or struggles to apply it effectively, leading to repeated mistakes or slow improvement.	Seeks feedback regularly and incorporates it into their work; shows a willingness to learn and grow based on guidance from more experienced engineers.	Actively seeks feedback, quickly incorporates suggestions, and demonstrates significant improvement over time; takes initiative to learn beyond immediate tasks.
Leadership & Process Improvement	Struggles to follow established processes and adapt to the team’s workflows. Rarely seeks opportunities to improve their personal efficiency or workflow.	Follows established processes effectively and seeks ways to improve their own workflow. Adapts to team processes and tools with minimal guidance.	Demonstrates self-discipline by proactively improving personal workflows and processes. Consistently seeks ways to work more efficiently and adapts to team processes quickly.

What makes a good L1 engineer?

When someone talks about a strongly performing L1 engineer}, you may hear that they:

Make sure their changes are well-tested and always cover those tricky edge cases.
Actively seek out feedback during code reviews and quickly apply suggestions.
Write clear, easy-to-understand documentation for any features or bug fixes they work on.
Work well with teammates, asking thoughtful questions to get a better sense of the bigger picture.
Regularly join team discussions and ask great questions during meetings.
Are alway eager to jump in and take on bug fixes, getting them done with little supervision.
Show a good understanding of version control, making clean commits and following the team’s practices for branching and pull requests.
Adapt quickly to team processes, including things like CI/CD, sprint planning, and standups.
Frequently test their work both locally and with automated tests before submitting it for review.
Don’t hesitate to ask for help when something’s unclear, showing a real willingness to learn.
Consistently meet deadlines and keep the team updated on progress.

Managing L1 Software Engineers

The primary goal when managing L1 engineers is creating a supportive learning environment while building their confidence through structured growth opportunities. Success at this level is as much about developing good habits and understanding professional software development as it is about technical skills.

Key approaches

Break work into small, well-defined tasks with clear success criteria
Establish regular 1:1s focused on both technical growth and professional development
Pair them with more senior engineers who can provide day-to-day guidance
Create psychological safety around asking questions and making mistakes
Provide context about how their work connects to broader product goals
Set explicit expectations about when to ask for help (e.g., "if you're stuck for more than 30 minutes")

Development focus areas

Code quality fundamentals
Testing practices and the "why" behind different types of tests
Git workflow and collaboration tools
Basic debugging and problem-solving strategies
How to read and understand existing codebases
Documentation practices and clear communication

Measuring progress

Focus on learning velocity rather than output
Look for increasing independence on similar types of tasks
Track their ability to help others with problems they've previously solved
Notice improvements in their questions and problem-solving approach
Monitor their growing understanding of the product and user needs

Common pitfalls to avoid

Overwhelming them with too much responsibility too quickly
Assuming knowledge of development tools and practices
Not providing enough context for assigned tasks
Letting them struggle alone for too long
Focusing solely on technical skills while neglecting professional development