JavaScript, React, Node.js, Express, MongoDB, REST APIs, testing and deployment.
What you will cover
JavaScript
React
Node.js
Express
MongoDB
REST APIs
testing
deployment
Topic list from the institute's programme record.
Certification
Certificate terms for this programme are confirmed by the institute at admission. Any ADIVAS course-completion certificate is an institute certificate; it is not a university degree, an externally accredited qualification or a vendor certification (such as AWS or Microsoft) unless the institute states so in writing.
Curriculum 0.1 · Draft: written for ADIVAS and awaiting academic review and approval. Topics and weeks may change before your batch starts.
Your skill trail
You move through 7 stations. Each week builds one skill you can show, not just a topic you have heard.
1
Web and JavaScript foundations
Build responsive pages and write modern asynchronous JavaScript confidently.
Week 1 HTML, CSS and Git basics
Week 2 JavaScript core I
Week 3 JavaScript core II and the DOM
Week 4 Asynchronous JavaScript and fetch
2
Node.js and Express
Build and structure an Express API with routing, middleware and consistent errors.
Week 5 Node.js fundamentals
Week 6 Express: routing and middleware
Week 7 REST design, validation and error handling
3
Data, security and API testing
Store data in MongoDB, secure the API and test it systematically.
Week 8 MongoDB fundamentals
Week 9 Mongoose models and relationships
Week 10 Authentication, authorisation and API security
Week 11 Testing the back end
4
React front end
Build a React application connected to the secured API with routing, forms and tests.
Week 12 React fundamentals
Week 13 Hooks, effects and forms
Week 14 Routing, context and application state
Week 15 Integrating the secured API and front-end testing
5
Delivery
Automate checks, containerise and deploy the full stack with safe configuration.
Week 16 Git collaboration, CI and Docker
Week 17 Deployment, configuration and monitoring basics
6
AI-assisted development
Use AI assistants productively while verifying every output and protecting data.
Week 18 AI-assisted development with review and responsible use
7
Capstone
Plan, build, harden and present a complete MERN application.
The ADIVAS mastery ladder: how each skill is recognised
Explored You have seen the idea and tried a first example.
Practising You can do it with hints and keep improving.
Proficient You complete the weekly practical task correctly on your own.
Proven You apply it in a project reviewed by your trainer.
Skill-level tracking is being added to the learner workspace. Your trainer already reviews weekly practical work.
What you will be able to do
Build responsive pages with semantic HTML and modern CSS.
Write clear, modern JavaScript including functions, objects, modules, promises and async/await.
Build REST APIs with Node.js and Express using routing, middleware, validation and consistent error handling.
Design MongoDB collections and use Mongoose for CRUD, validation and relationships.
Secure an application with password hashing, JWT authentication, authorisation and basic hardening.
Build React interfaces with components, hooks, routing, forms and API integration.
Test across the stack: API tests with Supertest, component tests and manual checks, using clear test cases.
Use Git workflows, Docker and continuous integration, and deploy with configuration kept outside the code.
Draw and explain client-server, API-flow and data-model diagrams for a MERN application.
Use AI coding assistants responsibly: verify suggestions, protect private data and record where AI helped.
Plan, build, present and document a capstone application.
Who it suits
School Class 11–12 students who enjoy building things with code and want to see how a real web app works, learning concepts and a small working version.
College Students and recent graduates who want a project-based path to JavaScript web development with a deployable portfolio.
Professional Working professionals and career changers with some programming exposure who want to build and ship complete web applications.
Prerequisites: Basic programming logic in any language: variables, conditions, loops and functions. Comfort with computers and file management. HTML, CSS and JavaScript are taught from the start. Tools: VS Code, A current LTS version of Node.js and npm, React with Vite, Express and Mongoose, MongoDB (local or Atlas free tier) and MongoDB Compass, Git and GitHub, Postman or a similar API client, Jest or Vitest, Supertest and React Testing Library, Docker and GitHub Actions, An AI coding assistant used with review.
Weekly plan
Web and JavaScript foundations Weeks 1–4
Week 1: HTML, CSS and Git basics
Theory
Semantic HTML, forms and accessibility basics
CSS selectors, box model, flexbox and grid
Responsive design with media queries
Git: init, commit, branch and push to GitHub
Lab
Build a responsive one-page site for a local tuition centre with a navigation bar, course cards and an enquiry form, and push it to GitHub.
Homework
Check the page on a phone-width viewport and fix two layout problems.
Deliverable
A responsive static site in a GitHub repository with at least five commits.
Weekly checkpoint
Fix a broken flexbox layout and describe what each commit contains.
You will be able to
Build responsive pages with semantic HTML and modern CSS. Use Git workflows, Docker and continuous integration, and deploy with configuration kept outside the code.
Week 2: JavaScript core I
Theory
let, const, data types and operators
Functions, arrow functions and scope
Arrays and array methods: map, filter, reduce
Objects and destructuring
Lab
Write functions to filter, sort and total a list of product objects (name, price, stock) and print a summary.
Homework
Solve ten array and object exercises and write a test case table for three of them.
Deliverable
inventory.js with documented sample output.
Weekly checkpoint
Predict the output of five array-method snippets and fix a scope error.
You will be able to
Write clear, modern JavaScript including functions, objects, modules, promises and async/await.
Week 3: JavaScript core II and the DOM
Theory
The DOM, selecting elements and events
Closures and this in outline
ES modules: import and export
Error handling with try/catch and the console as a debugger
Lab
Add JavaScript to the tuition site: a course filter, a form validator and a dark-mode toggle saved in localStorage.
Homework
Split the script into two modules and explain the imports.
Deliverable
Interactive site with working filter and validation.
Weekly checkpoint
Debug an event handler that never fires and a closure-in-loop bug.
You will be able to
Write clear, modern JavaScript including functions, objects, modules, promises and async/await. Build responsive pages with semantic HTML and modern CSS.
Week 4: Asynchronous JavaScript and fetch
Theory
The event loop and why async exists
Promises, then/catch and async/await
fetch, JSON and handling network errors
HTTP methods and status codes
Lab
Fetch posts from a public test API, show loading, error and empty states and add a manual retry.
Homework
Rewrite a promise chain using async/await and explain the order of console logs in a given snippet.
Deliverable
A page that lists remote data with proper loading and error handling.
Weekly checkpoint
Predict the output order of a snippet mixing setTimeout and promises; fix a missing await.
You will be able to
Write clear, modern JavaScript including functions, objects, modules, promises and async/await. Draw and explain client-server, API-flow and data-model diagrams for a MERN application.
Node.js and Express Weeks 5–7
Week 5: Node.js fundamentals
Theory
Node runtime, npm and package.json
CommonJS versus ES modules
Built-in modules: fs, path, http
Environment variables and dotenv
Lab
Write a Node script that reads a JSON file of students, adds a record and writes it back; then create a bare HTTP server returning JSON.
Homework
Explain what node_modules, package.json and the lock file each do.
Deliverable
A Node project with a script and a plain HTTP server.
Weekly checkpoint
Read a package.json and identify scripts and dependencies; fix a require path error.
You will be able to
Build REST APIs with Node.js and Express using routing, middleware, validation and consistent error handling.
Week 6: Express: routing and middleware
Theory
Express app, routes and request/response objects
Middleware: built-in, custom and order of execution
Route parameters, query strings and body parsing
Project structure: routes, controllers, services
Lab
Build a notes API with in-memory data: GET, POST, PUT and DELETE, plus a custom request-logger middleware.
Homework
Draw the middleware chain for a POST request and mark where each middleware runs.
Deliverable
A running Express API with a Postman collection.
Weekly checkpoint
Order the middleware steps and fix a route that hangs because next() was not called.
You will be able to
Build REST APIs with Node.js and Express using routing, middleware, validation and consistent error handling. Draw and explain client-server, API-flow and data-model diagrams for a MERN application.
Week 7: REST design, validation and error handling
Theory
Resource naming, status codes and idempotency
Input validation with a schema library
Central error-handling middleware
CORS and API versioning basics
Lab
Add validation and a central error handler to the notes API; make every failure return the same JSON error shape.
Homework
List ten invalid requests with the expected status and message.
Deliverable
Documented endpoint table and an API that never leaks stack traces.
Weekly checkpoint
Choose status codes for six situations and spot an unvalidated field.
You will be able to
Build REST APIs with Node.js and Express using routing, middleware, validation and consistent error handling.
Data, security and API testing Weeks 8–11
Week 8: MongoDB fundamentals
Theory
Documents, collections and BSON
CRUD operations and query operators
Embedding versus referencing in schema design
Indexes and when they help
Lab
Create a database for a training centre in Atlas or locally, insert 20 course and student documents and write queries for filters, sorting and counts using Compass and the shell.
Homework
Design a schema for orders and products and justify embedding or referencing for each relation.
Deliverable
A documented data model diagram and a query script.
Weekly checkpoint
Write queries from descriptions and decide between embedding and referencing in two cases.
You will be able to
Design MongoDB collections and use Mongoose for CRUD, validation and relationships. Draw and explain client-server, API-flow and data-model diagrams for a MERN application.
Week 9: Mongoose models and relationships
Theory
Connecting to MongoDB from Express
Schemas, models and validation rules
References, populate and aggregation basics
Handling duplicate keys and cast errors
Lab
Replace in-memory data with Mongoose models for courses and students, add enrolment references and an aggregation for enrolment counts per course.
Homework
Trigger and handle a duplicate-key error and an invalid ObjectId.
Deliverable
An API persisted in MongoDB with models, validation and an aggregation endpoint.
Weekly checkpoint
Read a Mongoose schema and write the query for a described report.
You will be able to
Design MongoDB collections and use Mongoose for CRUD, validation and relationships. Build REST APIs with Node.js and Express using routing, middleware, validation and consistent error handling.
Week 10: Authentication, authorisation and API security
Theory
Password hashing with bcrypt: never store plain passwords
JWT: issue, verify and expiry; refresh in outline
Role-based authorisation middleware
Helmet, rate limiting, CORS configuration and avoiding NoSQL injection
Lab
Add register and login routes issuing a JWT, a protect middleware and an admin-only route; add rate limiting to login.
Homework
Write a threat checklist for your API and the control for each threat.
Deliverable
Secured API with a table of public, authenticated and admin routes.
Weekly checkpoint
Find the flaw in a login handler and the missing authorisation check on an admin route.
You will be able to
Secure an application with password hashing, JWT authentication, authorisation and basic hardening.
Week 11: Testing the back end
Theory
Unit and integration tests with Jest or Vitest
API tests with Supertest and a test database
Writing test cases: happy path, boundary and failure
Mocking external services
Lab
Write twelve tests for the auth and course endpoints with a clean database for each run and a failing test fixed.
Homework
Add tests for two bugs you deliberately introduce so that they fail first.
Deliverable
A passing test suite and a short test-case table.
Weekly checkpoint
Complete a partial Supertest file and explain why a test depends on test order.
You will be able to
Test across the stack: API tests with Supertest, component tests and manual checks, using clear test cases.
React front end Weeks 12–15
Week 12: React fundamentals
Theory
Vite project, JSX and components
Props, state with useState and rendering lists with keys
Composition and lifting state
Thinking in components: breaking a design into pieces
Lab
Turn the tuition-centre design into React components with a course list, search and filter.
Homework
Sketch the component tree for a three-screen app and mark which component owns each state.
Deliverable
React course catalogue with at least five components.
Weekly checkpoint
Fix a missing key warning and predict re-renders for a small tree.
You will be able to
Build React interfaces with components, hooks, routing, forms and API integration.
Week 13: Hooks, effects and forms
Theory
useEffect and data fetching with cleanup
useRef, useMemo and when not to optimise
Controlled forms and validation
Custom hooks
Lab
Fetch courses from your API with loading and error states, build an add-course form and create a useFetch custom hook.
Homework
Fix a stale-state bug and an effect with a missing dependency.
Deliverable
React app reading and writing data through the API.
Weekly checkpoint
Debug an effect that causes an infinite loop and explain the dependency array.
You will be able to
Build React interfaces with components, hooks, routing, forms and API integration.
Week 14: Routing, context and application state
Theory
React Router: pages, params and protected routes
Context for auth state; when a state library is not needed
Error boundaries and not-found pages
Accessibility and keyboard checks
Lab
Add routes for catalogue, detail, login and admin; keep the user in context and protect admin routes.
Homework
Run a keyboard-only pass on your pages and fix three issues.
Deliverable
Multi-page app with login and protected routes.
Weekly checkpoint
Trace the login flow on a diagram and fix a redirect loop.
You will be able to
Build React interfaces with components, hooks, routing, forms and API integration. Secure an application with password hashing, JWT authentication, authorisation and basic hardening.
Week 15: Integrating the secured API and front-end testing
Theory
Attaching JWTs to requests and handling 401 responses
Token storage trade-offs: memory, cookies and local storage
Component tests with React Testing Library
Environment-based API URLs
Lab
Complete the integration, handle expired tokens gracefully and write six component tests for the form and the list.
Homework
Write a short note choosing a token storage approach with the risks of each.
Deliverable
Working full-stack app locally with tests on both sides.
Weekly checkpoint
Write a test for a form that shows an error on empty input; explain a CORS error.
You will be able to
Build React interfaces with components, hooks, routing, forms and API integration. Test across the stack: API tests with Supertest, component tests and manual checks, using clear test cases. Draw and explain client-server, API-flow and data-model diagrams for a MERN application.
Delivery Weeks 16–17
Week 16: Git collaboration, CI and Docker
Theory
Branching, pull requests, code review and conflict resolution
GitHub Actions: install, test and build on every push
Dockerfiles and Docker Compose for the API, front end and database
Lab
Add a CI workflow running both test suites, containerise the services and start the stack with one compose command.
Homework
Review a classmate's pull request with three specific comments.
Deliverable
Green CI pipeline and a compose file.
Weekly checkpoint
Read a workflow file and a Dockerfile and find a secret committed by mistake.
You will be able to
Use Git workflows, Docker and continuous integration, and deploy with configuration kept outside the code.
Week 17: Deployment, configuration and monitoring basics
Theory
Environment variables and secrets in production
Deploying the API, the React build and a managed MongoDB
HTTPS, health checks and structured logging
Backups and rollback thinking
Lab
Deploy the stack to a cloud platform, configure secrets through the platform, add a health endpoint and verify using logs.
Homework
Write a one-page runbook: deploy, roll back and check health.
Deliverable
Live URL and runbook.
Weekly checkpoint
Find why a deployed API fails using logs and list what must never be committed.
You will be able to
Use Git workflows, Docker and continuous integration, and deploy with configuration kept outside the code. Draw and explain client-server, API-flow and data-model diagrams for a MERN application.
AI-assisted development Weeks 18
Week 18: AI-assisted development with review and responsible use
Theory
Where AI helps: boilerplate, explanations, test ideas, refactoring
Where it fails: outdated or invented APIs, insecure code and confident mistakes
Privacy and honesty: no secrets in prompts; log where AI helped
Lab
Generate an Express route and its tests with an assistant, review for validation, security and correctness, fix the issues and write a review note.
Homework
Evaluate honestly whether the assistant saved time on three tasks and where it did not.
Deliverable
AI-use log and a review note attached to a pull request.
Weekly checkpoint
Review a prepared AI-generated route and list its defects.
You will be able to
Use AI coding assistants responsibly: verify suggestions, protect private data and record where AI helped.
Capstone Weeks 19–20
Week 19: Capstone build sprint
Theory
User stories, minimum viable scope and a task board
Feature branches and pull-request reviews
Definition of done: tests, docs and deployment
Lab
Build the capstone in two sprints with daily stand-ups; every feature has a pull request, a test and a review.
Homework
Update the board and write acceptance criteria for remaining work.
Deliverable
Working capstone core merged to main with tests.
Weekly checkpoint
Mid-point demo of the working core with test results.
You will be able to
Plan, build, present and document a capstone application. Test across the stack: API tests with Supertest, component tests and manual checks, using clear test cases.
Week 20: Capstone hardening and presentation
Theory
Security and performance checklist
README, API documentation and architecture diagram
Demo skills and reflection
Lab
Fix review findings, deploy the final version and rehearse a ten-minute demo with an architecture diagram.
Homework
Write a reflection on what you would improve and where AI helped or misled.
Deliverable
Deployed capstone, repository, documents and demo.
Weekly checkpoint
Final demo and viva before a review panel.
You will be able to
Plan, build, present and document a capstone application. Use Git workflows, Docker and continuous integration, and deploy with configuration kept outside the code. Draw and explain client-server, API-flow and data-model diagrams for a MERN application. Use AI coding assistants responsibly: verify suggestions, protect private data and record where AI helped.
Sample lessons
Week 6
Express middleware: the chain a request passes through
In Express, a request passes through a chain of functions called middleware before it reaches a route handler. Each middleware receives the request, the response and a next function. It can read or change the request, end the response, or call next() to pass control onward. Order matters: body parsing must come before routes that read req.body, authentication before protected routes, and the error handler last. Understanding this chain explains most Express bugs, especially requests that hang because next() was never called.
1Request arrives
2Logger middleware
3JSON body parser
4Auth middleware
5Route handler
6Response sent
Each middleware either answers or calls next().
Step by step
Create an Express app and add express.json() to parse JSON bodies.
Write a logger middleware that prints the method and path and calls next().
Add a protect middleware that returns 401 when the Authorization header is missing.
Mount routes after these middlewares and register an error handler at the end.
Send requests with and without a token and read the logger output.
In real life
A booking API needs to log every request, check the login token and only then let the booking route run. Each of these jobs is a small middleware in the chain.
Worked example
Problem. A POST /api/notes request returns an empty req.body. What is wrong with this setup? app.post('/api/notes', create); app.use(express.json());
Solution. express.json() is registered after the route, so the body is never parsed before create runs. Move app.use(express.json()) above the routes. Middleware runs in the order registered.
Common mistakes
Forgetting to call next() so the request never finishes.
Registering body parsers or authentication after the routes they should protect.
Sending a response and then calling next(), causing a headers-already-sent error.
Try it yourself
Write a middleware that rejects requests with a missing x-api-key header with 401.
Draw the chain for POST /api/bookings with logger, parser, protect and handler.
Week 14
The full MERN request flow with login
In a MERN application, React runs in the browser and calls an Express API over HTTP. Express checks the JWT sent in the Authorization header, applies the business rules and uses Mongoose to read or write MongoDB. The JSON result returns to React, which updates its state and re-renders the screen. Each layer has a clear job: React handles display and user input, Express handles rules and security, and MongoDB stores the data. Secrets and permission checks must live on the server, because anything in the browser can be read or changed by the user.
React in the browser: screens, forms, state
Express API: JWT check, rules, validation
Mongoose models: schemas and queries
MongoDB: stored documents
Security rules live in the server layers.
Step by step
User submits the login form; React sends POST /api/auth/login with the email and password.
Express finds the user with Mongoose and compares the bcrypt hash.
On success it returns a signed JWT with an expiry.
React stores the token and sends it in the Authorization header for later calls.
A protect middleware verifies the token before returning protected data.
In real life
On a services-booking site, after you log in, opening My Bookings sends your token to the API, which returns only your bookings from MongoDB.
Worked example
Problem. A user opens /admin by typing the URL. React hides the Admin link for normal users. Is the admin data safe?
Solution. No. Hiding the link is only a convenience. The Express admin route must check the JWT and the role and return 403 for non-admins. Any security rule in React alone can be bypassed by calling the API directly.
Common mistakes
Relying on React to hide admin features without a server-side role check.
Storing a long-lived token in local storage without considering theft through XSS.
Putting the JWT secret in front-end code or in Git.
Try it yourself
Draw the sequence from login click to showing My Bookings and mark where the token is created and checked.
List what the server must verify on POST /api/bookings.
Try the questions
The same skills are asked at three levels: School (Classes 6–12), College and Professional. Switch the level and the language (English or Tamil), and say how sure you are before you check: knowing what you are unsure about is part of learning.
Classes 6–12: everyday examples, no prior knowledge. Practice only. Nothing here is graded or saved.
Question 1 / 4 · Client-server idea
When you open a website, your phone asks a far-away computer for the page. What do we call the computer that answers?
Local service providers in Madurai such as electricians and tutors take bookings over phone calls and lose track of them. Build a MERN application where customers browse providers, book a slot and view their bookings, and providers or admins manage listings and confirm bookings.
Tasks
Design the MongoDB data model for users, providers and bookings and draw it as a diagram.
Build Express APIs with validation, JWT authentication, role-based access and a consistent error shape.
Build a React interface with search, provider detail, booking form, login and a provider dashboard.
Write API tests with Supertest and component tests for the booking form; run them in CI.
Containerise and deploy the stack with secrets outside the code, a health endpoint and a runbook.
Keep an AI-use log with what was generated, what you changed and how you verified it.
Sample input
POST /api/bookings {"providerId": "66f1...a2", "slot": "2026-11-03T10:00", "note": "Fan repair"}
Expected output
201 Created with the booking document; booking the same provider and slot again returns 409 with a clear message; the customer sees the booking under My Bookings.
How it is assessed
Criterion
Weight
Working features and data handling
25%
API design, security and validation
20%
React interface and usability
15%
Tests and CI evidence
15%
Deployment, documentation and diagrams
15%
Responsible AI use and demo
10%
Stretch challenge: Add email or SMS style reminders with a scheduled job and a provider calendar view.
Personal Expense Tracker API and Dashboard (mid-course)
Build an Express and MongoDB API for recording expenses by category with JWT login, and a small React dashboard that lists expenses and shows totals per category.
Tasks
Create Mongoose models for User and Expense with validation.
Implement authenticated CRUD and an aggregation endpoint for totals per category.
Build a React list, add form and totals view with loading and error states.
Write at least eight API tests including failure cases.
Sample input
POST /api/expenses {"title": "Bus pass", "amount": 600, "category": "Transport"}
Expected output
201 Created; GET /api/expenses/summary returns category totals such as {"Transport": 600}; requests without a token return 401.
How it is assessed
Criterion
Weight
Correct API and data behaviour
35%
Authentication and validation
25%
React dashboard
20%
Tests
20%
Stretch challenge: Add monthly filtering and a simple bar chart.
How you are assessed
Each week: a short quiz with code-reading and debugging questions, one lab task submitted through a Git repository and a pull-request review. Fortnightly: an architecture or API-flow diagram exercise.
Practical work. Learners submit code, test cases, diagrams and deployed links; trainers run the tests, read the history, ask design questions and set a live debugging task.
What trainers look for
Weight
Correct, working features
30%
Code quality, structure and security
20%
Tests and debugging evidence
20%
Architecture diagrams and documentation
15%
Responsible AI use and collaboration
15%
Where this can lead
Prepares you for junior full-stack and front-end or back-end JavaScript roles through a portfolio of deployed projects.
Builds the base for further study of TypeScript, Next.js, cloud and DevOps.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
