Skip to content
All tech roadmaps

Software Development

Backend Development

Backend engineers own the data and the rules. The work is designing APIs other teams can build on, modelling data so it stays correct under load, and being the person who understands why the system is slow at 9am.

6 stages3 projectsBeginner friendly6 to 9 months, part time

Start here

Pick one language from Stage 2 and refuse to be tempted by another for six months. Language-hopping is the single most common reason people stall on this path.

01

Foundations

The layer underneath every backend framework you will ever use.

Required

How servers and networks work

Backend bugs are usually somewhere between two machines, not inside one function.

What to learn

  • HTTP in detail
  • Status codes and headers
  • DNS
  • Ports and processes
  • TLS in outline

Tools

  • curl
  • Browser developer tools

Practice

Make the same request with curl and in the browser. Compare the headers line by line.

Next: Linux, because that is what your code will run on.

Required

The command line and Linux

Production is a Linux box. Being slow in a terminal makes every later stage slower.

What to learn

  • Navigating a filesystem
  • Permissions
  • Processes and logs
  • SSH
  • Basic shell scripting

Practice

Deploy nothing, but SSH into a cheap virtual machine and read its system logs until they make sense.

Next: A language.

02

One language, deeply

Depth in one is worth more than familiarity with four.

Choose one primary backend language.

All three are employable. Choose on job market and on which one you will actually enjoy at 11pm on a Tuesday.

Pick one

Python

The gentlest syntax and a direct bridge into data and AI work later.

What to learn

  • Types and data structures
  • Functions and modules
  • Virtual environments
  • Error handling
  • Testing with pytest

Tools

  • Python
  • FastAPI or Django

Next: APIs.

Pick one

Node.js and TypeScript

One language across frontend and backend, which is a real advantage if you already know JavaScript.

What to learn

  • Async and promises
  • Modules
  • TypeScript types
  • npm and dependencies
  • Testing

Tools

  • Node.js
  • TypeScript
  • Express, Fastify or NestJS

Next: APIs.

Pick one

Go

Fast, simple and increasingly the default for infrastructure work. A smaller but well-paid market.

What to learn

  • Types and structs
  • Interfaces
  • Goroutines and channels
  • Error handling as values
  • The standard library

Tools

  • Go
  • net/http
  • chi or Echo

Next: APIs.

03

APIs and data

The core of the job, and where the design decisions that matter live.

Required

Designing an HTTP API

An API is a contract other people build against. Changing it later is expensive, so getting the shape right early pays for years.

What to learn

  • Resources and verbs
  • Status codes that mean something
  • Pagination and filtering
  • Versioning
  • Error response shape
  • OpenAPI documentation

First understand

  • Your chosen language

Practice

Write the OpenAPI spec for an API before writing a line of its code.

Next: SQL. Almost every API is a database with manners.

Required

SQL and relational modelling

The highest-leverage skill on this entire path. A good schema prevents bugs that no amount of application code can fix.

What to learn

  • SELECT, JOIN, GROUP BY
  • Normalisation
  • Primary and foreign keys
  • Indexes
  • Transactions
  • Reading a query plan

Tools

  • PostgreSQL
  • A SQL client

Practice

Take a slow query, run EXPLAIN on it, add one index, and measure the difference.

Project

beginner

A REST API with persistence

A CRUD API over a relational database with input validation, pagination, sensible error responses and documentation. No authentication yet.

  • Your language
  • PostgreSQL
  • OpenAPI

You can design and build an API another developer could use without asking you questions.

Next: Authentication, because now the data is worth protecting.

Optional

When not to use SQL

Worth understanding so you can explain why you chose Postgres, which is the answer most of the time.

What to learn

  • Document stores
  • Key-value stores
  • When denormalisation genuinely helps

Tools

  • MongoDB
  • Redis

Next: Authentication.

04

Authentication, authorisation and safety

Given its own stage because it is the part juniors most often get wrong, and the part where getting it wrong is expensive.

Required

Authentication and sessions

Proving who someone is, and knowing when to stop believing it, is the foundation everything else sits on.

What to learn

  • Password hashing
  • Sessions versus tokens
  • JWTs and their limits
  • Refresh tokens and expiry
  • OAuth in outline

Practice

Implement password login end to end once, by hand, so you understand exactly what a managed service is doing for you later.

Next: Authorisation, which is the harder half.

Required

Authorisation and input safety

Most real breaches are not exotic. They are a missing permission check or an unvalidated input.

What to learn

  • Role and attribute based access
  • Validating every input at the boundary
  • Parameterised queries
  • Rate limiting
  • Secrets handling
  • The OWASP Top Ten

Tools

  • A schema validation library
  • A secrets manager

Practice

Try to access another user's record by changing an id in the URL of your own project. Fix what you find.

Next: Making it fast.

05

Making it hold up

What changes when more than one person uses it at once.

Recommended

Caching and performance

The cheapest performance win available, and the easiest thing to get subtly wrong.

What to learn

  • Cache layers
  • Invalidation strategies
  • N+1 queries
  • Connection pooling

Tools

  • Redis

Next: Background work.

Recommended

Queues and background jobs

Anything slow — email, image processing, reports — must leave the request path or your API becomes unusable.

What to learn

  • Job queues
  • Retries and idempotency
  • Scheduled work
  • Dead letter handling

Tools

  • Redis and a worker library
  • A managed queue

Next: Observability.

Required

Logging and observability

The job continues after deployment. You need to find out something is broken before a user tells you.

What to learn

  • Structured logging
  • Metrics
  • Tracing in outline
  • Health checks
  • Useful alerts

Project

intermediate

A multi-user service

An API with authentication, role-based permissions, a background job, caching on the hottest endpoint, and structured logs. Load test it and write down where it breaks.

  • Your language
  • PostgreSQL
  • Redis
  • A load testing tool

You know the concurrency at which your own system falls over, and why.

Next: Deployment.

06

Run it in production

Where backend work stops being theoretical.

Required

Containers and deployment

Being able to hand someone a running system, not a repository, is what closes the gap to a job offer.

What to learn

  • Dockerfiles
  • Environment configuration
  • Database migrations
  • CI/CD
  • Zero-downtime deploys

Tools

  • Docker
  • GitHub Actions
  • A managed platform

Project

advanced

A production-style deployment

Take your multi-user service, containerise it, deploy it behind a domain with TLS, automate migrations in the pipeline, and add alerting on error rate.

  • Docker
  • GitHub Actions
  • A cloud provider

You can take an idea to a monitored, deployed system on your own.

Where this leads

You do not have to pick one now. These are the directions this path opens up once you are working.

You do not have to do this alone

Our programs are free, taught live, and built around the same progression. Join one and work through it alongside other people.