Back-end Technology

₦30,000

Pre-enrolling for next cohort — starts 29 June 2026(Tentative)

⏳

Pre-enrol for Next Cohort is active. Registration is open but your cohort begins on 29 June 2026 (tentative). You'll receive access when classes begin.

Curriculum

A rigorous, project-driven curriculum for building the invisible layer that powers every app, website, and platform you've ever used. By Week 6, you will have built and deployed real APIs, connected live databases, secured your endpoints with authentication, and shipped a full backend project you own.

Highlights

Basic JavaScript familiarity recommended (LTN Frontend or Intro to Tech)
6 portfolio projects, all live and deployed
Node.js · Express · PostgreSQL · MongoDB · REST APIs · Authentication · Deployment
3 classes per week · 40–60 minutes per class
Methods inspired by Harvard CS50W and MIT 6.031 Software Construction

What You'll Learn

Frontend vs. backend — what a server actually does and why it matters
The client-server model and the request-response cycle
HTTP methods: GET, POST, PUT, PATCH, DELETE — and when each is correct
HTTP status codes: 200, 201, 301, 400, 401, 403, 404, 500 — reading the server's language
JSON: the format backends and frontends use to communicate
The terminal: navigating directories, creating files, running scripts
Node.js: running JavaScript outside the browser for the first time
npm: installing, managing, and understanding packages and dependencies
Environment setup: Node.js, VS Code, Postman, and your first .js script

Project

Project 1 — The HTTP Explorer

Use Postman to make 10 real HTTP requests to five different public APIs — a weather API, a currency exchange API, a public government dataset, a sports data API, and one of your choice. For each request, document: the method used, the status code returned, what triggered it, and what the response body contains. Write a short explanation of the difference between GET and POST, and why a server returns 401 vs. 403. Delivered as a documented Postman collection and a written summary.

What You'll Learn

What a framework is and why Express exists instead of raw Node.js
Setting up an Express application from scratch
Defining routes: GET, POST, PUT, DELETE with app.get(), app.post(), etc.
Route parameters (/users/:id) and query strings (?search=value)
Request and response objects: req.body, req.params, req.query, res.json()
What middleware is and how the request pipeline works
Writing custom middleware: logging, timing, and request validation
Built-in middleware: express.json() and express.urlencoded()
Organizing a growing codebase with Express Router
Nodemon: restarting the server automatically during development

Project

Project 2 — Personal Notes API

Build your first REST API from scratch: a notes application with full CRUD operations stored in memory. Five routes — list all notes, get one note by ID, create a note, update a note, delete a note. All routes tested and documented in Postman. This API will be upgraded with a real database in Week 3.

What You'll Learn

Why in-memory storage disappears when the server restarts — and why that is unacceptable
Relational databases: tables, columns, rows, primary keys, and foreign keys
SQL fundamentals: SELECT, INSERT, UPDATE, DELETE, JOIN
Designing a schema before writing any code — the habit that prevents expensive mistakes
One-to-many and many-to-many relationships explained with real examples
Setting up PostgreSQL locally and in the cloud with Railway or Supabase
Connecting Node.js to PostgreSQL using the pg library
Parameterized queries: the only real defense against SQL injection
Reading and writing data through your API routes with a real database behind them

Project

Project 3 — Notes API with PostgreSQL

Upgrade your Week 2 Notes API: replace in-memory storage with a real PostgreSQL database. Same five routes, same behavior — but now data survives a server restart. Includes a schema diagram, parameterized queries throughout, and the database hosted on Railway or Supabase. Delivered as an updated GitHub repository with setup instructions in the README.

What You'll Learn

What makes an API truly RESTful: resource naming, HTTP semantics, statelessness
Consistent JSON response structure: data, message, and status on every response
Input validation: never trusting what the client sends without checking it first
Validation libraries: express-validator and Zod — what each offers
Centralized error handling middleware: one place to catch and format all errors
Custom error classes for structured, predictable error responses
Environment variables with dotenv: keeping secrets out of your codebase and off GitHub
API versioning: /api/v1/ and why it exists
Building a multi-resource API with relationships between tables

Project

Project 4 — Blog API

Design and build a multi-resource REST API for a blog platform: users and posts with a one-to-many relationship. Full CRUD for both resources, input validation on every POST and PUT route, centralized error handling, environment variables for all secrets, and a fully documented Postman collection. This is the API that gets secured in Week 5.

What You'll Learn

Why authentication is non-negotiable and how it works under the hood
Hashing passwords with bcrypt — storing plain text is never an option
JSON Web Tokens: header, payload, signature — what each part contains and why
Signing and verifying tokens with the jsonwebtoken library
The register → login → protected route flow built entirely from scratch
Writing authentication middleware that blocks unauthenticated requests
HTTP-only cookies vs. Authorization headers — the real tradeoffs
Role-based access control: making sure users can only touch their own data
Rate limiting login routes against brute-force attacks with express-rate-limit
CORS: why browsers block cross-origin requests and how to configure it correctly

Project

Project 5 — Auth-Protected Blog API

Add full authentication to your Week 4 Blog API. Users register and log in. Posts are protected — only authenticated users can create, update, or delete. Users can only modify their own posts. Passwords stored as bcrypt hashes, tokens expire after a set window, rate limiting on the login route, and CORS configured correctly. Delivered as an updated, fully secured GitHub repository.

What You'll Learn

Introduction to MongoDB and Mongoose: when a document database suits the problem better than SQL
File uploads with Multer: accepting images and documents from clients
Storing uploaded files in the cloud with Cloudinary
Sending transactional emails on user actions with Resend or Nodemailer
Deploying a Node.js API to Railway or Render with a real production URL
Environment variables in deployment dashboards — not in your code
Pagination: never returning every record at once
Health check endpoints: GET /health and what production monitoring looks like
Writing a professional README for a backend project
Next steps: TypeScript, GraphQL, microservices, system design

Capstone Project — Build and Deploy a Real Backend API

Define a real problem and build a complete, deployed backend API to solve it. A marketplace, an event booking service, a school management system, a community platform — anything that demonstrates multiple resources, real authentication, a live database, and production deployment.

A live API URL is required to complete the course.

Required:

Minimum 3 related resources with full CRUD
JWT authentication protecting all write routes
Input validation and centralized error handling throughout
Real database: PostgreSQL or MongoDB
API deployed live on Railway or Render
All environment variables set in the deployment dashboard
Full Postman collection documenting every endpoint
Architecture diagram showing how the resources relate
GitHub repository with professional README
3-minute demo video walking through the API in Postman

End-of-Course Outcome

6 Projects — A Complete Backend Portfolio

Week	Project	Output
Week 1	The HTTP Explorer	Postman Collection · Written Summary
Week 2	Personal Notes API	REST API · In-Memory · GitHub
Week 3	Notes API with PostgreSQL	Database-Backed API · Live Database
Week 4	Blog API	Multi-Resource API · Postman Docs
Week 5	Auth-Protected Blog API	Secured API · JWT Authentication
Week 6	Capstone Backend API	Live Deployed API · Full Documentation

You finish the course with a live, documented API portfolio, a GitHub profile showing real backend code at every stage, and the ability to build and deploy server-side applications independently.

Why This Curriculum Works

Every Project Builds on the Last

The Notes API gains a database in Week 3. The Blog API gains authentication in Week 5. The authenticated API gets deployed in Week 6. Students watch one real system grow instead of starting from scratch each week — which is exactly how backend development works in practice.

Security Is Not Week Six

bcrypt, parameterized queries, environment variables, input validation, and rate limiting are introduced progressively from Week 3 onward. By the time students reach the capstone, security is a habit not a checklist.

The Database Transition Is Taught, Not Assumed

Week 3 upgrades the existing API from memory to PostgreSQL using the same routes and same behavior. Students see exactly what changes and why — making the database layer concrete instead of abstract.

Deployed, Not Just Built

The capstone requires a live production URL on Railway or Render. Students graduate having completed the full pipeline from writing a route to running it in production — the part most backend tutorials leave out.

Methods inspired by Harvard CS50W and MIT 6.031 Software Construction

Price

₦30,000