Backend Developer

Full outline

Everything behind the API: a language and runtime, data modelling and databases, API design, caching, queues, authentication, observability and the distributed-systems thinking that keeps production alive under load.

1. 01Computing Foundations

   The layer under every framework you will ever use.

   • Operating systems

     Processes, threads, memory and I/O. When a service degrades at 3am, this is the vocabulary you debug in.

   • Networking

     TCP/IP, TLS, DNS and the request lifecycle end to end.

   • Linux & the terminal

     Servers are Linux. Fluency in the shell is non-negotiable.

   • Data structures & algorithms

     Not just interview theatre — it is how you choose between an O(n²) and an O(n log n) endpoint.

2. 02Pick A Language

   Go deep in one. The second is far easier than the first.

   • Node.js & TypeScript

     Shares a language with the frontend, huge ecosystem, excellent for I/O-bound services.

   • Python

     The default for data, ML and fast API development.

   • Gooptional

     Small language, enormous concurrency payoff, single-binary deploys.

   • Java, C# or Rustoptional

     Enterprise-heavy or performance-critical alternatives.

3. 03API Design

   Your API is a product. Someone has to live with it.

   • REST done right

     Resource modelling, correct status codes, and versioning you won't regret.

   • GraphQLoptional

     One flexible endpoint. Powerful, and easy to misuse.

   • gRPC & protobufoptional

     Binary, typed, fast — the common choice for service-to-service calls.

   • Contracts & documentation

     An undocumented API is an unusable one.

4. 04Databases & Data

   Where nearly every real performance problem actually lives.

   • SQL & relational modelling

     Still the correct default for the overwhelming majority of applications.

   • Indexes & query plans

     The highest-leverage backend skill there is. A single index routinely turns 4 seconds into 4 milliseconds.

   • Transactions & isolation

     ACID, isolation levels, deadlocks, and the anomalies each level still permits.

   • NoSQL & specialised stores

     Different shapes of data want different engines.

   • Migrations & ORMs

     Schema changes on a live database, without downtime or data loss.

5. 05Caching, Queues & Scale

   Doing less work beats doing work faster.

   • Caching strategies

     The fastest query is the one you never run — and the hardest bug is a stale cache.

   • Queues & background jobs

     Anything slow, flaky or non-critical belongs off the request path.

   • Scaling patterns

     Vertical, horizontal, and knowing which bottleneck you actually have.

   • Distributed systems reality

     Once there are two machines, new failure modes appear that no single server ever had.

6. 06Auth & Security

   The part where mistakes become headlines.

   • Authentication

     Proving who someone is, without storing anything you'd hate to leak.

   • Authorisation

     Proving what someone is allowed to do. Broken access control tops the OWASP list for a reason.

   • Application security

     The attacks that actually happen, and the defaults that stop them.

7. 07Ship & Operate

   Writing it is half the job. Running it is the other half.

   • Containers

     Reproducible environments from your laptop to production.

   • CI/CD

     Every commit tested; every merge deployable.

   • Observability

     Logs, metrics and traces — the three ways production tells you what it's doing.

   • Testing backends

     Confidence to deploy on a Friday.

   • System design

     Turning vague requirements into an architecture you can defend — in interviews and in design reviews.