Build Real REST APIs
Create the server-side functionality behind websites, mobile apps and other clients.
Live online backend development bootcamp
Stop Just Building Frontends. Start Engineering the Backend.
Master Node.js, Express.js, REST APIs & Authentication — live with Thapa Technical.
Live now — join the running batch. Batch 2 is on the Node.js module, daily at 9:00 PM IST.
Learn how real backend applications work. Build secure REST APIs, connect a database, implement authentication, write maintainable server-side code, and deploy real-world Node.js applications.
POST
/api/v1/auth/login
Request bodyapplication/json
{ "email": "student@example.com", "password": "••••••••" }
- Client
- Express
- Auth
- MySQL
- JSON
Response200 OK
{ "success": true, "message": "Login successful", "user": { "id": 101, "role": "developer" } }
Why backend
Frontend makes it look good. Backend makes it work.
Every login, payment, search and dashboard you have ever built a screen for depends on a server somewhere: an API that checks who you are, reads the right data and sends back an answer. This course teaches you to build that part yourself.
Stop depending on someone else to build your backend.
Handle Authentication & Security
Understand how login systems, tokens, permissions and protected routes work.
Connect a Real Database
Connect your API to MySQL and save real data with safe, simple queries.
Deploy Real Applications
Learn how to run, configure and monitor backend applications in production.
Technologies
The tools you will master in this Node.js & Express.js live course
One focused stack, used the way backend teams use it: JavaScript on the server, Express for the API, the basics of MySQL for saving data, and the tooling to test, secure and deploy it.
Core
-
JavaScriptThe language
-
Node.jsRuntime
-
Express.jsWeb framework
-
npmPackages & scripts
Data & security
- REST APIsAPI design
-
MySQL* Only the basics
-
JWTAuthentication
-
ZodRequest validation
Tooling
-
PostmanAPI testing
-
GitVersion control
-
GitHubCode hosting
Deployment
-
PM2Process manager
-
NginxReverse proxy
* MySQL: only the basics. This is a backend course: you learn how to connect your Express API to MySQL and run simple queries. Database design in depth is not covered.
Logos are trademarks of their respective owners and are shown only to identify the technologies taught.
Complete roadmap
From your first Express route to a deployed REST API.
Six modules, taught live and in order. Every module ends with a milestone you build and run yourself. Open any module to see every topic.
Module 01 · 15 topics
Backend & Node.js Foundations
How the web really works, and how Node.js runs JavaScript outside the browser.
What we cover
- How the web works
- Client-server architecture
- HTTP and HTTPS fundamentals
- What is a backend?
- Node.js runtime and V8
- Installing Node.js
- npm and package.json
- CommonJS vs ES Modules
- Built-in modules
- File system
- Path and URL modules
- Environment variables
- Event loop fundamentals
- Callbacks, Promises, async/await
- Streams and buffers fundamentals
You will be able to
- Explain what happens between a browser request and a server response
- Use Node.js built-in modules and npm packages with confidence
- Write non-blocking async code and know why it matters
MilestoneBuild a simple Node.js server and a CLI utility
Module 02 · 16 topics
Express.js & REST API Development
Routes, middleware and controllers: the shape of every real Express API.
What we cover
- Introduction to Express.js
- Express application setup
- HTTP methods
- Routes and route parameters
- Query parameters
- Request and response objects
- Middleware
- Express Router
- Controllers and services
- RESTful conventions
- CRUD operations
- HTTP status codes
- Request validation
- Centralized error handling
- Filtering, pagination and sorting
- API response structure
You will be able to
- Design clean REST endpoints with the right methods and status codes
- Structure an app into routers, controllers and services
- Validate input and return consistent, predictable errors
MilestoneBuild a complete CRUD REST API
Module 03 · 9 topics
Connecting a Database (MySQL Basics)
Just enough MySQL to give your API real, saved data. Not a database course.
What we cover
- Why an API needs a database
- Tables, rows and columns
- Basic SQL: INSERT, SELECT, UPDATE, DELETE
- Connecting Node.js to MySQL
- Connection pools
- Parameterized queries (no SQL injection)
- Database credentials in environment variables
- Using the database inside Express routes
- Handling database errors
You will be able to
- Connect an Express API to a MySQL database
- Run basic create, read, update and delete queries from Node.js
- Keep database credentials out of your code
MilestoneSave your API's data in MySQL instead of in memory
Module 04 · 16 topics
Authentication, Authorization & Security
Login systems, tokens and permissions, built properly instead of copied.
What we cover
- Register and login APIs
- Password hashing
- JWT fundamentals
- Access and refresh tokens
- Cookie-based authentication
- Authentication middleware
- Protected routes
- Authorization
- Role-based access control
- Secure configuration
- CORS
- Rate limiting
- HTTP security headers
- Input validation
- Common API vulnerabilities
- Safe error responses
You will be able to
- Implement register, login and token refresh end to end
- Protect routes and enforce roles with middleware
- Recognise and close the most common API security holes
MilestoneBuild a secure login and role-based authorization system
Module 05 · 13 topics
Professional Backend Engineering
The habits that make a codebase easy to test, debug and hand over.
What we cover
- Clean folder structure
- Controllers, services and repositories
- Reusable middleware
- API documentation
- Postman collections
- Unit and integration tests
- Structured logging
- Debugging
- Error management
- File uploads
- Environment separation
- Git and GitHub workflow
- Backend coding best practices
You will be able to
- Organise a growing API so features stay easy to add
- Write tests that catch regressions before users do
- Document and share an API with Postman collections
MilestoneRefactor and test an API using maintainable architecture
Module 06 · 13 topics
Deployment & Capstone Project
Put everything together and run it on a real server.
What we cover
- Build a complete backend application
- Database integration
- Auth and authorization
- API validation
- Admin and user permissions
- Production environment variables
- Deployment fundamentals
- PM2
- Nginx and reverse proxy concepts
- HTTPS and basic hardening
- Logs and troubleshooting
- Deployment verification
- Production readiness checklist
You will be able to
- Deploy a Node.js API behind Nginx and keep it running with PM2
- Configure production secrets and HTTPS safely
- Debug a live server from its logs
MilestoneDeploy a real-world REST API project
All six modules, taught live by Thapa Technical.Batch running · join with recordings · 9:00 PM IST · ₹1,999 · Only 10 seats
Enroll in Backend Live Classes Backend architecture
See what happens behind every API request.
This is the path every request takes through the APIs you will build. Select a stage to see what it does and the code behind it, or play a request through all seven stages.
Stage 1 of 7
Frontend / Client
Any client can talk to your backend. It does not care how the API is built; it only sends a request and expects a predictable response.
fetch('/api/v1/tasks?status=open', {
headers: { Authorization: `Bearer ${token}` }
});Stage 2 of 7
HTTP Request
The request carries everything the server needs: the method (GET, POST...), the path, query parameters, headers such as the auth token, and an optional JSON body.
GET /api/v1/tasks?status=open HTTP/1.1
Host: api.example.com
Authorization: Bearer eyJhbGciOi...Stage 3 of 7
Express.js Router
Express matches the method and path against your routes and decides which chain of middleware and which controller should handle it.
const router = express.Router();
router.get('/tasks', requireAuth, listTasks);
app.use('/api/v1', router);Stage 4 of 7
Middleware & Validation
Before your business logic runs, middleware verifies the token, checks permissions and validates input. Bad requests stop here with a clear 4xx error.
function requireAuth(req, res, next) {
const token = req.headers.authorization?.split(' ')[1];
if (!token) return res.status(401).json({ success: false });
req.user = jwt.verify(token, process.env.JWT_SECRET);
next();
}Stage 5 of 7
Controller & Business Logic
The controller reads the validated input, applies the rules of your application and asks the service or repository layer for data.
async function listTasks(req, res) {
const { status, page = 1 } = req.query;
const tasks = await taskService.list(req.user.id, { status, page });
res.json({ success: true, data: tasks });
}Stage 6 of 7
Database
Data is read and written with parameterized queries, so user input can never rewrite your SQL. A connection pool reuses connections instead of opening a new one per request.
const [rows] = await pool.query(
'SELECT id, title, status FROM tasks WHERE user_id = ? AND status = ? LIMIT 20',
[userId, status]
);Stage 7 of 7
JSON Response
The client gets a status code and a JSON body in the same shape every time, which makes your API easy to consume and easy to debug.
HTTP/1.1 200 OK
Content-Type: application/json
{ "success": true, "data": [ { "id": 7, "title": "Write tests", "status": "open" } ] }Real-world projects
Don't just learn backend. Build one.
Three projects, each one harder than the last, built live with you in class.
Project 1
Task Management REST API
Your first complete API: clean routes, real validation and predictable errors.
- GET
/api/v1/tasks?status=open&page=2 - POST
/api/v1/tasks - PATCH
/api/v1/tasks/:id - DELETE
/api/v1/tasks/:id
- CRUD endpoints
- Validation
- Filtering
- Pagination
- Error handling
Project 2
Authentication & User Management API
A real login system with hashed passwords, tokens and roles.
- POST
/api/v1/auth/register - POST
/api/v1/auth/login - POST
/api/v1/auth/refresh - GET
/api/v1/users/me - PATCH
/api/v1/admin/users/:id/role
- Registration and login
- JWT authentication
- Password hashing
- Protected routes
- Role-based permissions
- Database integration
Capstone
E-Commerce Backend API
Products, carts and orders with admin rules, saved in MySQL and deployed.
- GET
/api/v1/products?category=laptops - POST
/api/v1/cart/items - POST
/api/v1/orders - PATCH
/api/v1/admin/products/:id/stock
- Products & categories
- Users
- Cart
- Orders
- Inventory logic
- Admin authorization
- Data saved in MySQL
- API testing
- Deployment
Build all three projects with us, live.Batch running · join with recordings · 9:00 PM IST · ₹1,999 · Only 10 seats
Join the live batch Who should join
Already know JavaScript? It's time to go beyond the browser.
Turn JavaScript knowledge into real backend development skills.
JavaScript learners who want to understand server-side development
React developers ready to learn the backend their apps talk to
Students preparing for full-stack projects
Developers who want to create real REST APIs
Learners who want practical experience with APIs, authentication and connecting a database
Basic JavaScript knowledge recommended.
You will follow comfortably if you know functions, objects, arrays, Promises and async/await. JavaScript fundamentals are not taught in this batch. New to JavaScript? Start with the JavaScript Live Classes (₹999) first.
Thapa Technical
Your instructor
Vinod Bahadur Thapa
Thapa Technical
The instructor behind Thapa Technical, known for practical, step-by-step developer tutorials. In this batch he teaches live: writing the code in front of you, explaining each decision, and answering your doubts as they come up.
- Practical live coding
- Step-by-step explanations
- Real project implementation
- Backend architecture fundamentals
- Doubt discussions during live sessions
Learn backend from Thapa Technical, live.Batch running · join with recordings · 9:00 PM IST · ₹1,999 · Only 10 seats
Enroll now What you get
Everything you need to learn backend properly.
Instructor-led live classes
Live at 9:00 PM IST with Thapa Technical. Ask questions while the code is being written.
Practical coding sessions
Every concept is coded live, then used in a project, not left as theory.
A structured, project-led roadmap
Six modules in a fixed order and three backend projects, finishing with a deployed e-commerce API.
Doubt solving
In the live room and in the batch WhatsApp group.
Recordings, code and notes
Every session recorded on your Vault, with source code, notes and API collections.
Completion certificate
A Kodyfier certificate of completion for the course.
This course is live
You learn in scheduled live sessions with the instructor and the batch. That is where questions get answered and code gets reviewed.
Recordings are a backup
Recordings help you revise or catch up on a missed class. Want a fully self-paced course instead? See the recorded Backend: NodeJS, Express & MySQL course.
Enrollment
Your backend development journey starts here.
One fee for the full live batch: all six modules, the three projects, the recordings and the certificate.
Enroll today and you get the recordings of every session already taught, then join the remaining classes live with the batch.
Node.js + Express Live Class
Batch in progress · join with recordings
₹1,999one-time fee
- Batch
- Started Monday, 2 November 2026
- Class time
- 9:00 PM IST, live online
- Batch size
- Only 10 seats
- Prerequisite
- Basic JavaScript
- Daily live classes at 9 PM IST with Thapa Technical
- Recording of every session on your Vault
- Source code, notes and API collections
- Doubt-solving in the live room and on WhatsApp
- Kodyfier certificate of completion
Secure checkout via Easebuzz. Access details within 24 hours. Students in Nepal: NPR 2,999, payable on the same checkout. Fees are non-refundable.
Ask on WhatsAppIncluded free: Kodyfier Vault
- Recordings of every live class, organised day by day
- 450+ aptitude practice questions with step-by-step solutions
- Full-length aptitude mock tests for placement first rounds
- Ask doubts under any lesson and get answers from the instructor
- Class notes and resources to download
- Email reminder before every live class
Vault access stays free for 1 year after your batch ends.
FAQ
Questions before you enroll
Is this a live class or a recorded course?
It is a live class. Every session is taught live online at 9:00 PM IST by Vinod Bahadur Thapa (Thapa Technical), and you can ask questions while he codes. Each session is also recorded and added to your Vault so you can revise or catch up on a class you missed. If you would rather learn fully self-paced, the recorded "Backend: NodeJS, Express & MySQL" course is a separate product.
When do the Node.js and Express.js classes start?
The current batch started on 2 November 2026 and runs daily at 9:00 PM IST. Enroll today and you get the recordings of every session already taught, then join the remaining classes live with the batch.
Do I need to know JavaScript before joining?
Yes, basic JavaScript is recommended. You should be comfortable with functions, objects, arrays, Promises and async/await. JavaScript fundamentals are not taught in this batch; if you are new to JavaScript, start with the JavaScript Live Classes first.
Will we create real REST APIs?
Yes. You build a Task Management REST API, an Authentication and User Management API, and an E-Commerce backend API as the capstone, with validation, pagination, error handling and role-based permissions.
Which database will we learn?
MySQL, but only the basics. This is a backend course, so the focus is Node.js and Express. You learn just enough MySQL to connect your API to a database: simple tables, basic insert, select, update and delete queries, a connection pool and parameterized queries. Database design in depth (joins, indexes, transactions) is not part of this batch, and neither is MongoDB. To go deeper into SQL, the recorded Backend: NodeJS, Express & MySQL course covers it in detail.
Will authentication and JWT be covered?
Yes. A full module covers register and login APIs, password hashing, JWT access and refresh tokens, cookie-based authentication, protected routes and role-based access control, plus CORS, rate limiting and security headers.
Will we build and deploy a project?
Yes. The last module is a capstone: you build a complete backend and deploy it, running it with PM2 behind Nginx as a reverse proxy, with production environment variables, HTTPS and a production readiness checklist.
Are recordings available?
Yes. Every live session is recorded and added to your Vault together with the source code, notes and API collections. The recordings are there for revision and missed classes; the course itself is taught live.
Can React developers join?
Yes. If you already build frontends with React, this batch teaches you to build the APIs those apps call: routes, authentication, connecting a database and deployment.
How can I enroll?
Click "Enroll in Backend Live Classes" on this page. You are taken to the Kodyfier checkout, where you pay securely via Easebuzz. Your access details arrive within 24 hours and you are added to the batch WhatsApp group. Students in Nepal see the NPR fee and payment option on the same checkout page.
Will I receive a completion certificate?
Yes. You receive a Kodyfier certificate of completion for this course.
How is this different from the Full Stack + AI course?
The Full Stack + AI Bootcamp Live Class is a 150-day programme for beginners that starts from HTML and CSS and covers React, Next.js, MySQL and AI tools (₹5,999). This batch is a focused backend course for people who already know JavaScript: Node.js, Express.js, authentication, MySQL basics and deployment, for ₹1,999.
How many students are in a batch?
Each batch has only 10 seats. Classes are live, so a small batch means your questions get answered in the session.
Is there a refund?
No. Like every Kodyfier checkout, the payment is final and non-refundable, so please check the timing and the JavaScript prerequisite before enrolling.
Node.js + Express.js · Live
Turn your JavaScript into a backend that ships.
Current batch started 2 November 2026. Enroll today and you get the recordings of every session already taught, then join the remaining classes live with the batch. Six modules, three projects, one deployed API.