About Backend Development
Backend development is the craft of building the servers, databases, and APIs behind
every app a user touches, and this course walks through it in the order most
developers actually learn it. It starts with How the Internet Works
(HTTP, DNS, and hosting), then Pick a Backend Language and
Version Control & Repo Hosting so you can write and track real
code.
Next comes Relational Databases: modelling data, writing SQL, and
running CRUD operations against PostgreSQL or MySQL. From there,
Building APIs covers REST, GraphQL, and gRPC, while
Authentication & Security covers JWT, OAuth, sessions, password
hashing, and the OWASP top risks.
Caching & Web Servers covers Redis, Memcached, Nginx, and Apache,
and Testing & CI/CD covers unit, integration, and functional
tests plus automating builds and deploys with a pipeline.
Finally, Architecture & Scaling covers monoliths and
microservices, message brokers, containerization, and load balancing, and
NoSQL & Observability covers document, key-value, and graph
databases along with monitoring systems in production: the skills that separate a
working service from one that stays up under load.
Content
10 modules
01
How the Internet Works
HTTP, domain names, DNS, and hosting, and how browsers and servers actually talk to each other.
HTTPDNSWeb Hosting
02
Pick a Backend Language
Learning one language deeply and building real projects with it: Python, JavaScript/Node.js, Java, Go, C#, Ruby, PHP, and Rust are all solid choices.
PythonJavaScript / Node.jsJava
03
Version Control & Repo Hosting
Tracking changes with Git and collaborating on code through GitHub or GitLab.
GitGitHubGitLab
04
Relational Databases
Modelling data, writing SQL, and running CRUD operations against PostgreSQL, MySQL, or another relational database.
PostgreSQLSQLIndexing
05
Building APIs
Designing and building a RESTful API, then exploring GraphQL and gRPC as other API styles.
RESTGraphQLgRPC
06
Authentication & Security
Implementing JWT, OAuth, and session-based auth, plus password hashing, HTTPS, and the OWASP top risks.
JWTOAuthOWASP Top 10
07
Caching & Web Servers
Speeding up responses with Redis or Memcached, and how web servers like Nginx and Apache serve traffic.
RedisNginxCache Invalidation
08
Testing & CI/CD
Writing unit, integration, and functional tests, then automating builds and deploys with a CI/CD pipeline.
Unit TestingGitHub ActionsContinuous Deployment
09
Architecture & Scaling
Monoliths vs microservices, message brokers, containerization, and the patterns behind systems that stay up under load.
DockerKubernetesMicroservices
10
NoSQL & Observability
Knowing when to reach for document, key-value, or graph databases, and how to monitor systems in production.
MongoDBPrometheusStructured Logging
Projects
5 builds
Solve the SQL Murder Mystery
Solve a murder mystery by writing SQL queries against a relational database, a hands-on drill for the first four modules.
Build a REST API with Node.js & PostgreSQL
Build a REST API with full CRUD operations against a PostgreSQL database, following a step-by-step Node.js tutorial.
Add JWT Authentication to an Express API
Create and verify JSON Web Tokens, protect routes with middleware, and handle token refresh and logout.
Speed Up an API with a Redis Cache
Cache database queries in Redis to make API responses faster and take load off your database.
Build Microservices with Docker Compose
Split an application into containerized services and run them together with Docker Compose.
What You Can Do After This Course
By the end of the curriculum you'll have worked through 5 hands-on projects and
covered the core of what a junior to mid-level backend role expects. Concretely,
you'll be able to:
Explain how the web works: what happens between a browser request and a server response, including DNS, HTTP, and HTTPS.
Write and version real code: build in the language you chose, tracked with Git and shared through GitHub or GitLab.
Model and query data: design relational schemas, write SQL, and add indexes where queries need them.
Build APIs: ship RESTful endpoints, and know when GraphQL or gRPC is the better fit.
Secure your services: implement JWT and OAuth flows, hash passwords properly, and guard against the OWASP top risks.
Make it fast and dependable: add Redis caching, put a web server in front, and back it all with automated tests and a CI/CD pipeline.
Scale and observe: split systems into containerized services, choose the right NoSQL store, and monitor with metrics, logs, and traces.