Backend
Node.js
30 topics cover Node.js across the Foundation 100.
Module 1 · Web Fundamentals
HTTP
How clients and servers communicate on the web through stateless request and response messages made of methods, paths, headers, and status codes.
REST APIs
A style for designing web APIs around resources, reusing HTTP methods and status codes so the interface is predictable and any client can consume it.
Authentication
The process of verifying that a request comes from the identity it claims, and how a stateless server keeps a user signed in after the first check.
Request Validation
Checking that incoming data has the expected shape and content before acting on it, so bad input is rejected early with a clear error.
Error Handling
Deciding deliberately what a service does when something goes wrong, separating expected errors from unexpected ones and returning safe, useful responses.
Module 2 · Node.js & Express Foundations
Node.js Runtime
How Node.js runs JavaScript outside the browser on the V8 engine, using a single-threaded event loop and non-blocking I/O to handle many requests at once.
npm & Package Management
How npm installs and version-controls the third-party packages a project depends on, using package.json to declare them and a lock file to make installs reproducible.
Node.js Modules (ES Modules & CommonJS)
How Node splits code into reusable modules, and the difference between the older CommonJS (require) and the standard ES Modules (import) systems.
Express.js Framework
A minimal, unopinionated web framework for Node.js that turns incoming HTTP requests into responses through a chain of routes and middleware.
Express Routing
How Express matches an incoming HTTP method and path to a handler, including route parameters and modular routers for organising endpoints.
Middleware
Functions that sit in the request pipeline and run before route handlers, used for cross-cutting concerns like parsing, authentication, logging, and errors.
Controllers
The layer that receives an HTTP request, coordinates the work, and returns a response, while delegating the actual business logic to services.
Services
The layer that holds an application’s business logic, kept separate from the HTTP layer so rules live in one place and can be reused and tested directly.
Dependency Injection
A design pattern where an object receives its collaborators from outside rather than creating them itself, making code looser-coupled and far easier to test.
Module 4 · API Design & Backend Patterns
DTOs
Data Transfer Objects define the exact shape of data crossing an API boundary, giving each request and response an explicit, validated contract.
Serialization
Converting in-memory objects into a transferable format such as JSON, and controlling exactly which fields are exposed so internal data never leaks.
Response Formatting
Giving an API a consistent response structure — for both success and error — so every client can parse results and handle failures the same way.
Pagination
Returning a large collection in smaller pages instead of all at once, using offset or cursor strategies to keep responses fast and bounded.
Filtering
Letting clients narrow a collection to the records they want through query parameters, safely translated into database conditions.
Sorting
Letting clients control the order of a collection through query parameters, over whitelisted fields and always with a stable tiebreaker.
File Uploads
Accepting binary files over HTTP with multipart form data, then validating type and size and storing the file safely outside the database.
API Versioning
Evolving an API without breaking existing clients by serving multiple versions, so a breaking change ships as a new version rather than in place.
Repository Pattern
A pattern that puts all data access for an entity behind a dedicated interface, so business logic works with a collection-like abstraction instead of raw queries.
Exception Filters
A centralised mechanism that catches errors thrown anywhere in request handling and turns them into consistent, safe HTTP responses.
Module 10 · Software Engineering & Architecture
Layered Architecture
Organising an application into horizontal layers — presentation, business logic, and data access — each with a clear responsibility and a one-directional flow.
Clean Architecture
An approach that puts business rules at the centre and makes all dependencies point inward, so frameworks, databases, and UI become replaceable details.
System Design Basics
Thinking about how the big pieces of a system — clients, servers, databases, caches, load balancers — fit together, and reasoning about the tradeoffs between them.
Scalability
A system's ability to handle growing load by adding resources — usually by scaling out across many stateless instances rather than up on one bigger machine.
Performance
How fast a system responds and how much it can do — improved by measuring first, then fixing real bottlenecks like slow queries, N+1 access, and missing caches.
Technical Debt
The accumulated cost of shortcuts and quick fixes that make future changes harder — a debt that charges interest and must be managed deliberately, not ignored.
Projects using Node.js
Practice Node.js on real Padlor projects — coming soon.