Software Development
Software Engineering
Software engineering is the discipline around programming: designing systems that survive change, working in a codebase you did not write, and being trusted with production. It is what separates someone who can code from someone a team can hire.
Start here
Start at Stage 1 with one language and stay with it. If you already program, skip to Stage 3 — that is where this path stops overlapping with the language-specific roadmaps.
One language, properly
Depth in one beats a shallow tour of four. Python and JavaScript are both fine starting points.
RequiredProgramming fundamentals
Everything after this assumes you can express an idea in code without looking up syntax every line.
Programming fundamentals
Everything after this assumes you can express an idea in code without looking up syntax every line.
What to learn
- Variables and types
- Control flow
- Functions
- Data structures
- Error handling
- Reading documentation
Practice
Next: Version control, before your work gets big enough to lose.
Working with other people
Introduced early because every job assumes it from day one.
RequiredVersion control
The most common thing a junior is assumed to know and most commonly has not practised under pressure.
Version control
The most common thing a junior is assumed to know and most commonly has not practised under pressure.
What to learn
- Commits and branches
- Merging and conflicts
- Pull requests
- Rebasing in outline
- Writing a commit message someone will thank you for
Tools
- Git
- GitHub
Practice
Next: Building something real with it.
Building for the web
Where most first jobs are, regardless of what you eventually specialise in.
RequiredA working application
Concepts stay abstract until something you built stores data and lets someone sign in.
A working application
Concepts stay abstract until something you built stores data and lets someone sign in.
What to learn
- HTML and CSS
- A frontend framework
- HTTP APIs
- Databases and SQL
- Authentication basics
First understand
- Programming fundamentals
- Git
Project
beginnerYour first complete application
An application with accounts, a database, and at least one thing a user can create, edit and delete. Deployed at a URL.
- Your language
- A database
- A hosting platform
You have shipped something end to end and can explain every part of it.
Next: The engineering practices that make it maintainable.
Working like an engineer
The difference between someone who codes and someone a team can hire. This is the stage that matters most.
RequiredTesting
Tests are how you change code confidently. Without them, every change is a gamble and the codebase calcifies.
Testing
Tests are how you change code confidently. Without them, every change is a gamble and the codebase calcifies.
What to learn
- Unit tests
- Integration tests
- Test doubles
- What is worth testing and what is not
- Test-driven development as a tool, not a religion
Next: Debugging.
RequiredDebugging methodically
Most engineering time is spent understanding why something does not work. Doing this by system rather than by guesswork is a learnable skill.
Debugging methodically
Most engineering time is spent understanding why something does not work. Doing this by system rather than by guesswork is a learnable skill.
What to learn
- Reproducing reliably
- Bisecting
- Reading stack traces
- Using a debugger rather than print statements
- Forming and testing one hypothesis at a time
Practice
Next: Reading code you did not write.
RequiredReading unfamiliar code
You will spend far more of your career reading code than writing it. Almost nobody practises this deliberately.
Reading unfamiliar code
You will spend far more of your career reading code than writing it. Almost nobody practises this deliberately.
What to learn
- Navigating a large codebase
- Tracing a request through layers
- Finding the right entry point
- Making a small change safely
Practice
Next: Code review.
RequiredCode review
How standards actually spread in a team, and the fastest way to learn from people better than you.
Code review
How standards actually spread in a team, and the fastest way to learn from people better than you.
What to learn
- Giving specific, kind feedback
- Receiving it without defensiveness
- Reviewing for design rather than style
- Knowing when to approve
Next: Design.
Designing software that survives change
Requirements always change. Design is what decides whether that is cheap or expensive.
RequiredDesign principles
Not for their own sake, but because they name the reasons a codebase becomes painful.
Design principles
Not for their own sake, but because they name the reasons a codebase becomes painful.
What to learn
- Separation of concerns
- Coupling and cohesion
- Composition over inheritance
- Naming
- Knowing when abstraction costs more than duplication
Next: Data structures and algorithms, in the amount that is actually useful.
RecommendedData structures and algorithms
Honestly: mostly for interviews. But complexity intuition genuinely does change how you write loops and queries.
Data structures and algorithms
Honestly: mostly for interviews. But complexity intuition genuinely does change how you write loops and queries.
What to learn
- Arrays, maps, sets
- Trees and graphs in outline
- Big O intuition
- Sorting and searching
- Recursion
Practice
Next: System design.
AdvancedSystem design
The interview format for mid-level roles onwards, and the actual skill of deciding where a feature should live.
System design
The interview format for mid-level roles onwards, and the actual skill of deciding where a feature should live.
What to learn
- Trade-offs rather than right answers
- Caching, queues and databases as building blocks
- Estimating load
- Drawing a system clearly
Project
intermediateA system with a written design
Before writing code, write a one-page design for a non-trivial feature: the data model, the API, the failure cases and one alternative you rejected. Then build it.
- A diagram tool
- Your stack
You can justify a design in writing before defending it in an interview.
Next: Production ownership.
Ship and maintain
Software that is not deployed does not count, and software nobody maintains stops working.
RequiredDeployment and operations
Owning your code in production is now part of almost every engineering role, not a separate job.
Deployment and operations
Owning your code in production is now part of almost every engineering role, not a separate job.
What to learn
- CI/CD
- Environment configuration
- Logging and monitoring
- Handling a production incident
- Rolling back
Tools
- Git
- GitHub Actions
- Docker
- A hosting platform
Project
advancedA maintained project
Take one project and maintain it for three months: automated tests in CI, dependency updates, error tracking, and a changelog. Fix something because monitoring told you to, not because you noticed.
- GitHub Actions
- An error tracker
You have experience of software as an ongoing responsibility rather than a one-off delivery, which is what the job actually is.
Where this leads
You do not have to pick one now. These are the directions this path opens up once you are working.
Backend Development
Specialise in data, APIs and services.
View roadmapFrontend Development
Specialise in interfaces and the people using them.
View roadmapDevOps Engineering
Specialise in delivery and reliability.
View roadmapQA & Test Automation
Specialise in correctness and confidence at scale.
View roadmapContinue your journey
The paths closest to this one. Skills overlap more than the job titles suggest.
Backend Development
Build the systems that store, protect and serve everyone's data.
ViewFrontend Development
Build the part of the product people actually touch.
ViewFull Stack Development
Own a feature from the database to the button someone clicks.
ViewDevOps Engineering
Automate the path from a commit to something running in production.
ViewWe teach this on Cloud Build with Peers
Our programs are free, taught live, and built around the same progression. Join one and work through it alongside other people.