What a backend is
The backend is the part of an app that runs on a server, out of sight: it stores the data, applies the rules, and answers requests from the app you see.
When you log in to a banking app, the screen you tap is the frontend. When you press “Send money”, the app sends a message (a request) over the internet to the bank’s backend. The backend checks that it’s really you, checks you have enough money, updates both accounts in the database, and sends back an answer (a response): “Transfer successful”. The frontend then shows you that message.
The backend exists because some things can’t be trusted to the user’s device. Anyone can tamper with an app on their own phone, so the rules that matter, such as “you can’t spend money you don’t have”, must be checked on a server you control.
This course teaches the ideas that are true whichever language or framework you use. The frameworks section then shows how to do them in JavaScript, Java, Python, C#, Go and Rust.
What you’ll be able to do
By the end you will be able to:
- explain what happens from the moment a request reaches a server until the response goes back;
- design an API, the set of requests your backend accepts and what it answers;
- organise backend code so it stays easy to change as it grows;
- use a database safely from your code;
- handle logging in and permissions: who you are, and what you’re allowed to do;
- deal with the things every feature needs, such as checking input, handling errors and limiting abuse;
- test a backend and check how it copes with heavy use.
Where to start
Read the sections in order. Section 03 is the heart of the course.
Before you start: you should be able to write basic code (Programming Fundamentals). Knowing a little about how the internet works and basic SQL helps.
01. Foundations
- What a Backend Actually Is: the backend’s four jobs, and the one rule behind all of them: never trust the user’s device.
- HTTP Servers: how a request physically reaches your server, and how the server answers.
- The Request Lifecycle: every step a request goes through inside your server, and how to work out which step a bug is in.
- Runtime and Concurrency Models: the three ways servers handle many users at once. It explains why frameworks behave differently, so read it before choosing one.
02. API Design
- APIs and REST: designing the requests your backend accepts and the answers it gives. Once other apps depend on it, it’s hard to change.
03. Structuring a Backend (the heart of the course)
- Layers: Controllers, Services, Repositories: splitting code into three jobs: receiving requests, applying business rules, and talking to the database.
- By Layer vs by Feature: two ways of arranging folders, and which keeps changes easier.
- Dependency Injection and Wiring: handing each piece of code the tools it needs instead of letting it create them, which makes testing much easier.
- Hexagonal and Clean Architecture: keeping your business rules separate from databases and frameworks, and what that costs.
- Modular Monolith to Services: when, and whether, to split one app into several.
04. Data and Persistence
- Databases in the Backend: using a database from your code: keeping changes all-or-nothing, handling two users editing at once, connection limits, and the most common performance mistake.
05. Auth
- Authentication Flows: checking who someone is: passwords, sessions and tokens.
- Authorization: checking what someone is allowed to do.
- OAuth Provider Integrations: “Sign in with Google” and similar.
06. Things Every Feature Needs
- Validation and DTOs: checking incoming data before using it.
- Configuration and Secrets: settings and passwords that shouldn’t be written into the code.
- Error Handling: failing clearly and safely, without leaking internal details.
- Rate Limiting: stopping one user from overwhelming your server.
- Idempotency and Retries: making sure a request sent twice (say, after a bad connection) doesn’t charge someone twice.
- Security Headers and CORS: browser rules that protect users, and how to allow other websites to call your API.
- File Uploads: accepting files from users safely.
Caching, monitoring and background jobs are taught in Architecture: building blocks and DevOps: observability.
07. Practices
- Backend Best Practices: habits that keep a backend healthy.
- Testing a Backend: checking your backend works, automatically.
- Load and Performance Testing: finding out how your backend copes with many users before real users find out.
Frameworks: the same ideas in your language
These aren’t in a reading order; pick the one you use. Read note 4 (Runtime and Concurrency Models) first: frameworks look like twenty different things to learn, but they’re really three ways of handling many users, with different names.
- JavaScript and TypeScript: Node, Express and Nest.
- Java: Spring Boot.
- Python: FastAPI, Django and Flask.
- C#: ASP.NET Core.
- Go: the standard library, Chi and Gin.
- Rust: Axum and Actix.
- C++ and C: when you’d actually use them, and when you wouldn’t.
- Cross-Language Recipes: rate limiting, login tokens, CORS, shutting down cleanly and logging, in all six languages side by side.
Practice
- Projects: hands-on tasks, from easy (🟢) to hard (🔴), each with a clear “done when”.
- Backend interview prep: built from a real interview. Production Debugging covers finding why a live system is slow or failing, and Node Runtime and API covers Node-specific questions.
Key ideas to remember
- Never trust the client. Anything from the user’s device can be faked, so check everything that matters on the server. → What a Backend Is
- Keep receiving requests, business rules and database code apart. When they’re mixed, every change touches everything. → Layers
- Frameworks differ mainly in how they handle many users at once. Understand the three models and every framework becomes easier. → Runtime and Concurrency Models
- Assume every request might arrive twice, and make sure that’s harmless. → Idempotency and Retries
Related
- Frontend: the other half of the app.
- Databases: where the backend’s data lives.
- Architecture: the same questions at the scale of whole systems.
- DevOps: getting a backend onto servers and keeping it running.
- Concepts: ideas that apply to all code, like clean code and design patterns.
About this course
- How it’s organised: sections 01–07 are true in any language. How one framework does something goes in
frameworks/<language>/. Ideas that apply beyond backends go in Concepts, and notes from real projects go in Projects. - History: restructured in August 2026. Before that, the ideas lived in a separate
concepts/01-backend/folder and this one held only framework notes.
Software engineering
Infrastructure & security
Computer science
Hardware & engineering