← Learning Pathways Learning Pathway

Graduate Engineer to Junior Software Engineer

🕑 9-18 months Software Engineering

Build the professional habits and independent delivery capability that turn a supervised learner into a reliable, self-directed contributor.

🎯 Focus Areas

Professional Software Habits

Graduates arrive knowing how to write code but not how to write production code. This means tests as a first-class concern, not an afterthought. It means commits that tell a story, PRs that are reviewable, and code that a colleague can understand at 2am during an incident.

Understanding the System

Your code does not live in isolation. Learn where it sits in the architecture, what calls it, what it calls, and what breaks when it misbehaves. Reading logs, traces, and metrics is a skill you should develop early - it changes how you write code.

Effective Code Review

Both giving and receiving code review are skills. Learn to give feedback that is specific, actionable, and kind. Learn to receive feedback without ego. Code review is your fastest learning mechanism as a junior - treat every comment as a free lesson.

Delivery Consistency

Reliability matters more than brilliance at this stage. Finish what you start. Communicate early when you are stuck. Break work into small, shippable slices. A junior who ships predictably is more valuable than one who occasionally produces impressive work but disappears for a week.

Asking Good Questions

There is an art to asking questions. Spend 30 minutes trying to solve something yourself before asking. When you do ask, explain what you have already tried. Good questions accelerate your learning and respect your colleagues' time.

⚡ Skills & Behaviours to Develop

Skills to Develop

  • Write unit and integration tests for every feature you build, aiming for meaningful coverage rather than a coverage percentage.
  • Use version control fluently including branching strategies, rebasing, resolving merge conflicts, and writing descriptive commit messages.
  • Read and navigate an unfamiliar codebase by tracing execution paths, reading tests, and using debugging tools rather than guessing.
  • Set up and run the application locally including dependencies, environment variables, and seed data.
  • Interpret application logs and basic metrics to diagnose a failing test or production anomaly.
  • Deliver a feature end-to-end from requirements to implementation to PR to deployed and verified in a test environment.
  • Communicate progress and blockers proactively in standups and async channels without being prompted.
  • Use a linter, formatter, and static analysis tool as part of your standard development workflow.

Behaviours to Demonstrate

  • Completes assigned tasks without requiring daily supervision and flags blockers within a few hours of hitting them.
  • Submits pull requests that include context on what changed, why, and how to test it.
  • Responds to code review comments constructively, asking clarifying questions rather than arguing or silently ignoring feedback.
  • Runs tests locally before raising a PR and does not rely on CI to catch issues that could be caught in 30 seconds.
  • Asks specific, well-researched questions and documents the answers for future reference.
  • Takes notes during architecture or technical discussions and follows up on action items without being chased.
  • Proactively reads pull requests from more senior engineers even when not assigned as a reviewer.
🛠 Hands-On Projects
1 Build a REST API from scratch with proper error handling, logging, and a full test suite, then deploy it to a cloud provider using a CI/CD pipeline you set up yourself.
2 Take a module from your team's existing codebase that has no tests and write a test suite for it, learning the codebase deeply in the process.
3 Contribute to an open source project by finding a good-first-issue, submitting a PR, and navigating the review process with an unfamiliar maintainer.
4 Build a small CLI tool that solves a real workflow problem you have, deploy it, document it, and share it with your team.
5 Set up a local observability stack using Prometheus and Grafana and instrument one of your own applications with meaningful metrics.
⚡ AI Literacy for This Transition
AI as a learning accelerator and code quality mirror
1

Use an AI coding assistant such as GitHub Copilot or Cursor for daily work but read and understand every suggestion before accepting it and never auto-accept blocks of code you cannot explain.

2

Practice using AI to explain unfamiliar code by pasting a function you do not understand and asking it to walk you through it, then verify the explanation by tracing the code yourself.

3

Use AI to generate test cases for code you have written, then critically evaluate whether the generated tests cover meaningful scenarios or just happy paths.

4

Ask AI to review your code before raising a PR and treat its feedback as one input among many rather than authoritative, noting explicitly where it is wrong or misleading.

5

Learn the limits of AI coding tools by asking them about your team's specific codebase and observing how often they produce plausible-sounding but incorrect details.

6

Read your organisation's AI usage policy and understand what code and data you are and are not permitted to send to external AI tools.

📚 Recommended Reading

The Pragmatic Programmer

David Thomas and Andrew Hunt

The foundational text for building professional software habits covering version control discipline, debugging, and how to think about engineering as a craft.

Clean Code

Robert C. Martin

Forces you to think explicitly about what makes code readable and maintainable, which is essential for a junior building their engineering taste.

A Philosophy of Software Design

John Ousterhout

A modern counterweight to Clean Code that focuses on managing complexity, the concept that will define how you write code for the rest of your career.

Working Effectively with Legacy Code

Michael Feathers

Most code you encounter as a junior will be legacy code and this book teaches you how to understand, test, and safely modify systems you did not write.

Software Engineering at Google

Titus Winters, Tom Manshreck, and Hyrum Wright

Concrete engineering practices at scale including testing culture, code review culture, and dependency management written by people who built systems millions rely on.

🎓 Courses & Resources

Test-Driven Development Path

Pluralsight

Builds the TDD habit from first principles and is essential for a junior who needs to internalise testing as part of development rather than a finishing step.

Git Complete: The Definitive Step-by-Step Guide

Udemy

Fills in the gaps in Git knowledge that most bootcamps and degrees skip, covering branching models, rebasing, and conflict resolution in depth.

CS50x

Harvard / edX

For graduates who came through vocational routes this fills foundational computer science gaps that will make you a better engineer long-term.

Debugging in Your IDE

JetBrains Academy or Microsoft Learn

Systematic debugging is a learnable skill and tooling-specific courses for your primary IDE pay off immediately in day-to-day productivity.

📋 Role Archetypes

Review the full expectations for both roles to understand exactly what good looks like at each level.

→ Graduate Engineer Archetype → Junior Software Engineer Archetype