Junior Software Engineer job description

Software engineering — Junior
Delivers well-scoped tasks with review and regular guidance.

RESPONSIBILITIES
- Pick up an unfamiliar area fast enough to be useful in it.
- Design, write, test and document a small program or script from a written specification, working under direction.
- Explain the main principles behind the team development standards and apply them to your own work once someone points you at the right practice for the situation.
- Review routine changes in your team codebase, spot missing tests and error handling, and separate a blocking objection from a preference.
- Diagnose defects in code you work on regularly, form a hypothesis before changing anything, and confirm a fix by reproducing the original failure and watching it stop.
- Keep a tidy local history, write commit messages that explain why, resolve routine conflicts yourself, and recover from a mistake with revert or reflog rather than starting the work again.

REQUIREMENTS
- No earlier level needed: this is the first level of the ladder

REQUIRED SKILLS
Software Development
- Programming and Build — You can design, write, test and document a small program or script from a written specification, working under direction. Your changes pass review with minor comments, and you follow the build and packaging steps without needing them explained again.
- Modern Development Standards — You can explain the main principles behind the team development standards and apply them to your own work once someone points you at the right practice for the situation.
- Code Review — You can review routine changes in your team codebase, spot missing tests and error handling, and separate a blocking objection from a preference. You take review on your own work without defensiveness.
- Debugging and Diagnosis — You can diagnose defects in code you work on regularly, form a hypothesis before changing anything, and confirm a fix by reproducing the original failure and watching it stop.
- Refactoring — You can rename, extract a function and delete dead code safely when a reviewer or a test suite confirms the behavior is unchanged.
- Version Control — You can keep a tidy local history, write commit messages that explain why, resolve routine conflicts yourself, and recover from a mistake with revert or reflog rather than starting the work again.
- API Design — You can add an endpoint or method that follows the patterns already in the codebase, and you can read an API specification and say what a given call will return.

Testing and Quality
- Test Design — You can select suitable test types for routine work with some support, and design cases covering the happy path, the boundaries and the obvious error paths. You set up a test environment when shown how.
- Test Automation — You can use the team frameworks and tooling to write reliable automated tests, and wire them into continuous integration so they run on every change. You fix the flaky tests you introduce.
- Performance Optimization — You can fix a performance problem someone else has located, such as an oversized image or a missing index.
- Accessibility Testing — You can explain that users have different access needs, and you can fix an accessibility defect that someone else has flagged, under direction.

Systems and Design
- Systems Design — You can read an existing design document and explain what the components are for and where they hand off to each other. You can draw the current shape of a system you work in without leaving out the parts you find confusing.
- Systems Integration — You can trace a call from one system into another and say what data crosses the boundary. You can run an existing integration test and read what it reports while someone works alongside you.
- Architectural Decisions — You can find the record behind a past technical decision and explain what was chosen, what was rejected and why.
- Schema and Query Design — You can read a schema and explain what each table holds and how the tables relate. You can write a simple query and, with help, tell whether the result answers the question that was actually asked.
- Prototyping and Spikes — You can build a small throwaway example to answer a question someone else has framed, and report what you found. You leave the code as an experiment rather than trying to turn it into production work.
- User Focus — You can describe who uses the software your team builds and what they are trying to do, using the user stories on the backlog.

Operations and SRE
- Continuous Delivery — You can push a change through the existing pipeline, read a failed stage and say which step broke. You ask first before doing anything by hand that the pipeline is meant to do.
- Observability and Monitoring — You can find the logs and dashboards for a service and use them to answer a simple question about what it is doing. You can add a log line where a reviewer suggests one.
- Production Incident Response — You can follow the incident process, keep a record of what you tried and hand over cleanly at the end of your shift. You escalate early rather than working alone on something you cannot yet judge.
- Availability and Capacity — You can explain what an availability target means for a service and where its current numbers are reported. You can see that a resource is near a limit once someone has shown you where to look.
- Infrastructure as Code — You can read the infrastructure definitions for a service and say what they create. You can make a small parameter change and get it reviewed and applied with support.

Security and Data
- Application Security — You can name the common classes of vulnerability that affect the code you write and fix one that a reviewer or a scanner has flagged. You ask for help before writing credential or authentication handling yourself.
- Secure Data Handling — You can tell personal data apart from other data in a system you work on, and you follow the rules on what may be copied, logged or displayed. You ask before moving data out of an environment.
- Dependency Management — You can add a library the team already uses, explain what a lock file is for and find which version a project depends on. You ask before introducing something new.

Delivery
- Project Management — You can keep your own tasks and deadlines in a current to-do list, and tell your manager as soon as work you own will be late.
- Planning & Estimation — You can estimate how long a task will take once the approach is clear, and you say promptly when the estimate turns out to be wrong.
- Ownership & Accountability — You can stay responsible after you hand work over: you check it did what it was meant to, fix your own mistakes, and give updates before anyone asks.
- Quality Focus — You can choose checks that suit the task in front of you, catch your own mistakes before anyone else sees them, and confirm the result works once people start using it.

Craft
- Problem Solving — You can work out what is wrong in work you did not create, and you fix the underlying cause instead of working around the symptom.
- Domain Expertise — You can apply the basics of your field to the work you are given, and ask an expert when a task goes beyond what you have learned.
- Continuous Learning — You can pick up an unfamiliar area fast enough to be useful in it, and you turn what you learned into something others can reuse.

Communication
- Communication — You can explain your work so your team can act on it, and play a request back in your own words before you act on it.
- Collaboration — You can work well with people in other roles, share context and credit, and take criticism of your work without defending territory.
- Writing & Documentation — You can document your own work well enough for a colleague to follow it unaided, such as a how-to guide or a handover, and keep it current as things change.
- Stakeholder Management — You can keep your manager and immediate team informed of your progress, and you raise an issue before someone else discovers it.

Leadership
- Leadership — You can act on direction well, seek feedback on how you work, and be open about what you need help with.
- Mentoring — You can share what you have just learned with your peers and help a newer colleague find their way around.
- Strategic Thinking — You can explain why the work you were given matters and who it is for.