Backend

Building the server side of an application: routing, middleware, APIs, and deployment.

Beginner

  1. What is Backend Development?: The part of an application that runs on a server rather than in the user's browser — handling logic, data, and rules the user should never see or control directly.
  2. Servers & Web Frameworks: What a web framework like Express actually does for you, versus the raw, repetitive plumbing you'd otherwise have to write by hand.
  3. Routing: The way a server decides which piece of code should handle a given URL and HTTP method.
  4. Middleware: Small functions that run before a request reaches its final route handler, each able to inspect, modify, or stop the request.
  5. Request/Response Lifecycle: The complete journey a request takes from the moment it arrives at your server to the moment a response is sent back.
  6. How Node.js Works: The JavaScript runtime that lets JavaScript run outside a browser, and the single-threaded, event-driven model behind it.
  7. Backend Project Structure: The folder and file layout that keeps routes, business logic, and data access separated as a backend app grows.
  8. npm & Package Management: How Node.js projects declare, install, and lock their external dependencies using npm and package.json.

Intermediate

  1. Environment Variables & Config: Keeping secrets and settings that differ between environments out of your code, so the same code can run safely in development, testing, and production.
  2. Error Handling in APIs: Catching errors in one central place and returning consistent, safe responses, instead of letting the server crash or leak internal details to callers.
  3. Validation & Sanitization: Checking that incoming data is well-formed and expected before your code uses it, and cleaning up anything unsafe it might contain.
  4. File Uploads: How a server receives a file sent from a form or client, at a conceptual level — and what happens to it once it arrives.
  5. Logging: Recording what a running server is doing in a structured, searchable way, so problems can be understood after the fact instead of only while watching a terminal.
  6. Background Jobs: Running work outside the normal request/response cycle, so a slow task doesn't force a user to sit and wait for it to finish.
  7. Connecting to a Database: The different ways backend code can talk to a database — raw drivers, query builders, and ORMs — and how a connection is actually established.
  8. FastAPI & Python Web Frameworks: How backend concepts like routing and middleware look in Python, using FastAPI as an example of a modern, async, type-driven framework.
  9. Authentication & Password Hashing: How a backend verifies who's making a request — never storing raw passwords, and remembering that someone is logged in across future requests.
  10. FastAPI Project Structure & Database CRUD: How a real FastAPI project is split into files, connects to a database with SQLAlchemy, and exposes full CRUD endpoints.

Advanced

  1. API Versioning: How to change an API's shape over time without breaking the other applications and clients already relying on it.
  2. Dependency Injection: Handing a function or class the things it needs from outside, rather than letting it create those things itself — making it far easier to swap or test.
  3. Testing Backend Code: The difference between checking one small piece of logic in isolation and checking that a real request flows correctly through the whole app.
  4. Deployment & CI/CD Basics: What actually happens between pushing a code change and that change running live for real users, at a conceptual level.
  5. Building with WebSockets: What actually changes on the server when a connection stays open — handling events, pushing messages, broadcasting, and what happens when a client drops.