Java, Spring Boot, SQL, React or Angular, REST APIs, testing, deployment and reviewed AI-assisted coding.
What you will cover
Java
Spring Boot
SQL
React or Angular
REST APIs
testing
deployment
reviewed AI-assisted coding
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
Core Java foundations
Write and debug object-oriented Java programs using collections, streams and exceptions.
Week 1 Java setup, syntax and control flow
Week 2 Methods, arrays, strings and exceptions
Week 3 Object-oriented Java: classes and encapsulation
Week 4 Inheritance, interfaces and polymorphism
Week 5 Collections, generics, lambdas and streams
2
Tooling, testing and databases
Work with Git and Maven, test code with JUnit, and design and query a relational database from Java.
Week 6 Git, Maven and unit testing with JUnit
Week 7 Relational databases and SQL basics
Week 8 Joins, aggregates, normalisation and indexes
Week 9 JDBC, transactions and SQL safety
3
Spring Boot back end
Build secure, validated and tested REST APIs on top of a database with Spring Boot.
Week 10 HTTP, REST principles and first Spring Boot app
Week 11 Controllers, services and dependency injection
Week 12 Spring Data JPA and Hibernate
Week 13 Relationships, validation and error handling
Week 14 Security: authentication, authorisation and JWT
Week 15 Testing the back end and documenting the API
4
React front end
Build a responsive React interface that talks to the API with routing, forms and authentication.
Week 16 Web fundamentals: HTML, CSS and modern JavaScript
Week 17 React fundamentals
Week 18 Hooks, routing and forms
Week 19 Connecting React to the secured API
5
Delivery and operations
Containerise, automate checks with CI and deploy with safe configuration and logging.
Week 20 Docker and continuous integration
Week 21 Deployment, configuration, logging and monitoring basics
6
AI-assisted development
Use AI assistants for coding, tests and review while verifying output and protecting data.
Week 22 AI-assisted development with review and responsible use
7
Capstone
Plan, build, harden and present a complete full-stack application.
Week 23 Capstone build sprint
Week 24 Capstone hardening, documentation and presentation
★
Training Centre Management System (capstone)
Your project, reviewed by a trainer.
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
Write clear Java programs using core syntax, object-oriented design, collections and exception handling.
Use Git, Maven and a debugger in a daily workflow and write JUnit tests for logic you build.
Design a relational schema and write SQL for CRUD, joins, aggregates and transactions.
Build secure REST APIs with Spring Boot, JPA/Hibernate, validation, error handling and JWT-based authentication.
Build a React front end with components, state, routing and forms that consumes a REST API.
Test across layers: unit tests with Mockito, API tests with MockMvc and manual checks with Postman.
Containerise with Docker, automate checks with CI and deploy the application with configuration kept outside the code.
Draw and explain client-server, API-flow and database architecture for the application.
Use AI coding assistants responsibly: prompt precisely, review every suggestion, test it, protect private data and record where AI helped.
Plan, build, present and document a capstone application as a small team or alone.
Who it suits
School Class 11–12 students who have tried basic programming and want to see how real web applications are built; they focus on the concepts and building a small version.
College Engineering and science students and recent graduates who want a structured, project-based route into Java web development.
Professional Working professionals and career changers who know some programming and want to build and deploy complete Java applications.
Prerequisites: Basic programming logic in any language: variables, conditions, loops and functions. Comfort with computers, files and a command line. Core Java is taught from the start. Tools: JDK (current long-term-support release), IntelliJ IDEA Community Edition or VS Code with Java extensions, Maven, Spring Boot with Spring Web, Data JPA and Security, PostgreSQL (or MySQL) and a SQL client, Node.js, npm and React with Vite, Git and GitHub, JUnit 5, Mockito and Postman, Docker and GitHub Actions, An AI coding assistant used with review.
Weekly plan
Core Java foundations Weeks 1–5
Week 1: Java setup, syntax and control flow
Theory
JDK, JRE and JVM: how Java source becomes running code
Primitive types, String, operators and type casting
if/else, switch, for, while and Scanner input
Lab
Install the JDK and an IDE; write a console program for a fee receipt that reads values with Scanner and prints a GST-inclusive total.
Homework
Solve ten small problems: even/odd, prime check, digit sum, Fibonacci, simple interest.
Deliverable
A Git-ready folder of ten solved console programs.
Weekly checkpoint
Code-reading quiz on operators and type casting plus one timed program.
You will be able to
Write clear Java programs using core syntax, object-oriented design, collections and exception handling.
Week 2: Methods, arrays, strings and exceptions
Theory
Methods, parameters, return values and overloading
Arrays, 2D arrays and common string methods
try/catch/finally, checked versus unchecked exceptions
Lab
Build a marks analyser using arrays and methods; handle non-numeric input and an out-of-range index with exceptions.
Homework
Write methods for palindrome check, word count and array reversal, each with a bad-input case.
Deliverable
MarksAnalyser.java with a README of sample runs.
Weekly checkpoint
Find the ArrayIndexOutOfBounds bug in a given program and explain a stack trace.
You will be able to
Write clear Java programs using core syntax, object-oriented design, collections and exception handling.
Week 3: Object-oriented Java: classes and encapsulation
Theory
Classes, objects, constructors and this
Encapsulation with private fields, getters and setters
static members, toString, equals and hashCode
Lab
Model a BankAccount class with deposit, withdraw and balance rules that throw an exception for overdraw.
Homework
Model a Student and a Course class and print a report using toString().
Deliverable
A small bank-account console app with at least five tested scenarios noted.
Weekly checkpoint
Code reading: predict the output of object creation with static counters.
You will be able to
Write clear Java programs using core syntax, object-oriented design, collections and exception handling.
Week 4: Inheritance, interfaces and polymorphism
Theory
Inheritance, super and method overriding
Abstract classes and interfaces
Polymorphism and composition over inheritance
Enums and records
Lab
Design a payment module with a PaymentMethod interface and UPI, Card and Cash implementations chosen at runtime.
Homework
Add a new payment type without changing the existing classes and explain why that works.
Deliverable
A class diagram and the working payment module.
Weekly checkpoint
Draw a class diagram from a given description and predict polymorphic call results.
You will be able to
Write clear Java programs using core syntax, object-oriented design, collections and exception handling. Draw and explain client-server, API-flow and database architecture for the application.
Week 5: Collections, generics, lambdas and streams
Theory
List, Set, Map and choosing between them
Generics and Comparable/Comparator
Lambdas and the Stream API: filter, map, collect
Optional and avoiding null errors
Lab
Load 20 product records into a list, then filter by price, group by category with a Map and sort by name using streams.
Homework
Count word frequency from a paragraph using a Map and then using streams.
Deliverable
ProductReport.java with five stream-based reports.
Weekly checkpoint
Choose the right collection for four scenarios and rewrite a loop as a stream.
You will be able to
Write clear Java programs using core syntax, object-oriented design, collections and exception handling.
Tooling, testing and databases Weeks 6–9
Week 6: Git, Maven and unit testing with JUnit
Theory
Git: commit, branch, merge, pull request and resolving a conflict
Maven project structure, dependencies and lifecycle
JUnit 5: assertions, test naming and the arrange-act-assert pattern
Using a debugger: breakpoints and watching variables
Lab
Move the bank account code into a Maven project, push it to GitHub, write eight JUnit tests including edge cases and fix two failures found.
Homework
Create a branch, make a change, open a pull request and merge it after a peer comment.
Deliverable
A GitHub repository with Maven build, passing tests and a meaningful commit history.
Weekly checkpoint
Write test cases for a given method and resolve a prepared merge conflict.
You will be able to
Use Git, Maven and a debugger in a daily workflow and write JUnit tests for logic you build.
Week 7: Relational databases and SQL basics
Theory
Tables, primary keys and data types
CREATE, INSERT, SELECT, UPDATE, DELETE
WHERE, ORDER BY, LIMIT and constraints (NOT NULL, UNIQUE)
Lab
Install PostgreSQL, design a courses-and-students schema for a training centre and insert 15 rows; write ten queries.
Homework
Write queries for unpaid fees, courses above a price and the newest five students.
Deliverable
schema.sql and queries.sql scripts that run from scratch.
Weekly checkpoint
Write five queries from a description and spot a missing WHERE in an UPDATE.
You will be able to
Design a relational schema and write SQL for CRUD, joins, aggregates and transactions.
Week 8: Joins, aggregates, normalisation and indexes
Theory
Foreign keys and one-to-many, many-to-many relationships
INNER and LEFT JOIN, GROUP BY, HAVING and aggregate functions
Normalisation to third normal form
Indexes and reading a query plan with EXPLAIN
Lab
Extend the schema with enrolments and payments; write joins for fee totals per course and students with no enrolment; add an index and compare EXPLAIN output.
Homework
Draw the entity-relationship diagram and normalise a deliberately messy fee sheet.
Deliverable
An ER diagram and a SQL file with eight join and aggregate queries.
Weekly checkpoint
Pick the right join for three situations and fix a GROUP BY error.
You will be able to
Design a relational schema and write SQL for CRUD, joins, aggregates and transactions. Draw and explain client-server, API-flow and database architecture for the application.
Week 9: JDBC, transactions and SQL safety
Theory
JDBC connection, PreparedStatement and ResultSet
Transactions, commit, rollback and ACID
SQL injection and why parameters matter
Lab
Write a Java DAO that inserts and reads students using PreparedStatement and demonstrate a transfer between two accounts that rolls back on failure.
Homework
Show a SQL injection attempt against a string-concatenated query and then block it with parameters.
Deliverable
A JDBC demo project with a documented transaction rollback test.
Weekly checkpoint
Code review: find the injection risk and the missing rollback in a given DAO.
You will be able to
Design a relational schema and write SQL for CRUD, joins, aggregates and transactions. Test across layers: unit tests with Mockito, API tests with MockMvc and manual checks with Postman.
Spring Boot back end Weeks 10–15
Week 10: HTTP, REST principles and first Spring Boot app
Theory
HTTP methods, status codes, headers and JSON
REST resource design and naming
Spring Boot project from Spring Initializr and the app startup flow
Client-server and API request flow
Lab
Create a Spring Boot project and a GET /api/courses endpoint with in-memory data; call it from a browser and from Postman.
Homework
Design the endpoint list, methods and status codes for a Student API on paper.
Deliverable
A running hello-API plus an endpoint table document.
Weekly checkpoint
Match status codes to situations and draw the request flow from browser to API.
You will be able to
Build secure REST APIs with Spring Boot, JPA/Hibernate, validation, error handling and JWT-based authentication. Draw and explain client-server, API-flow and database architecture for the application.
Week 11: Controllers, services and dependency injection
Theory
@RestController, @RequestMapping, @PathVariable and @RequestBody
Layered design: controller, service, repository
Dependency injection, beans and application.properties
DTOs versus entities
Lab
Implement full CRUD for courses in memory using controller and service layers; test every endpoint with Postman.
Homework
Export a Postman collection with at least one success and one failure case per endpoint.
Deliverable
Course CRUD API and a Postman collection.
Weekly checkpoint
Identify layer violations in sample code and explain constructor injection.
You will be able to
Build secure REST APIs with Spring Boot, JPA/Hibernate, validation, error handling and JWT-based authentication. Test across layers: unit tests with Mockito, API tests with MockMvc and manual checks with Postman.
Week 12: Spring Data JPA and Hibernate
Theory
Entities, @Id, @Column and mapping to tables
JpaRepository and derived query methods
Schema management with Flyway or Liquibase migrations
The N+1 query problem in outline
Lab
Replace in-memory storage with PostgreSQL via JPA; add a migration script and a custom query for courses by category.
Homework
Turn on SQL logging, observe the generated SQL and note two surprises.
Deliverable
Course API backed by the database with migration scripts.
Weekly checkpoint
Read an entity class and write the repository method for a described query.
You will be able to
Build secure REST APIs with Spring Boot, JPA/Hibernate, validation, error handling and JWT-based authentication. Design a relational schema and write SQL for CRUD, joins, aggregates and transactions.
Week 13: Relationships, validation and error handling
Theory
@OneToMany and @ManyToOne mappings
Bean Validation: @NotBlank, @Size, @Min
@ControllerAdvice and consistent error responses
Pagination and sorting
Lab
Add Student and Enrolment entities, validate input and return a clear 400 or 404 JSON error body.
Homework
List five invalid requests and the expected status and message for each.
Deliverable
API with relationships, validation and paged listing.
Weekly checkpoint
Fix a mapping that causes a serialisation loop and correct the wrong status code.
You will be able to
Build secure REST APIs with Spring Boot, JPA/Hibernate, validation, error handling and JWT-based authentication.
Week 14: Security: authentication, authorisation and JWT
Theory
Password hashing with BCrypt: never store plain passwords
Spring Security filter chain in outline
JWT issue and verification, roles and method security
CORS, HTTPS and common API risks
Lab
Add register and login endpoints returning a JWT and restrict admin endpoints to an ADMIN role.
Homework
Write a threat checklist for the API: what could go wrong and which control prevents it.
Deliverable
Secured API with a role-based access test table.
Weekly checkpoint
Identify the security flaw in a sample login controller.
You will be able to
Build secure REST APIs with Spring Boot, JPA/Hibernate, validation, error handling and JWT-based authentication.
Week 15: Testing the back end and documenting the API
Theory
Unit tests with Mockito for the service layer
Controller tests with MockMvc and repository tests with a test database
Test coverage as a guide, not a goal
OpenAPI documentation for the API
Lab
Write service tests with mocks, three MockMvc tests for the course endpoints and publish OpenAPI documentation.
Homework
Write a test for a bug you invent and fix, so that it fails first and then passes.
Deliverable
Back end with a passing test suite and a generated API document.
Weekly checkpoint
Complete a given test class and explain why a test is flaky.
You will be able to
Test across layers: unit tests with Mockito, API tests with MockMvc and manual checks with Postman. Draw and explain client-server, API-flow and database architecture for the application.
React front end Weeks 16–19
Week 16: Web fundamentals: HTML, CSS and modern JavaScript
Theory
Semantic HTML and forms
CSS box model, flexbox and responsive layout
JavaScript essentials: let/const, functions, arrays, async/await and fetch
Lab
Build a responsive course catalogue page in plain HTML, CSS and JavaScript that loads courses from your API.
Homework
Make the page usable on a phone-sized screen and check it with browser developer tools.
Deliverable
A responsive static catalogue page calling the Spring Boot API.
Weekly checkpoint
Fix a layout bug and read a fetch call with an unhandled error.
You will be able to
Build a React front end with components, state, routing and forms that consumes a REST API. Draw and explain client-server, API-flow and database architecture for the application.
Week 17: React fundamentals
Theory
Vite project, JSX and components
Props, state with useState and lists with keys
Lifting state and component composition
Lab
Rebuild the catalogue in React with a CourseCard component, a search box and a category filter.
Homework
Add a favourites list kept in state.
Deliverable
React catalogue with at least four components.
Weekly checkpoint
Predict re-render behaviour in a small component and fix a missing key.
You will be able to
Build a React front end with components, state, routing and forms that consumes a REST API.
Week 18: Hooks, routing and forms
Theory
useEffect and data fetching
React Router: pages, params and navigation
Controlled forms and client-side validation
Loading, empty and error states
Lab
Add course detail pages and an add-course form with validation and visible loading and error messages.
Homework
Handle a failed API call gracefully and show a retry button.
Deliverable
Multi-page React app with list, detail and create screens.
Weekly checkpoint
Debug a useEffect that loops forever and correct a form state bug.
You will be able to
Build a React front end with components, state, routing and forms that consumes a REST API.
Week 19: Connecting React to the secured API
Theory
Calling REST APIs and handling JSON
Login flow, token storage trade-offs and protected routes
CORS configuration between front end and back end
Environment variables for API URLs
Lab
Add login, store the token, protect admin pages and handle a 401 by redirecting to login.
Homework
Compare keeping a token in memory with other storage options and write a short recommendation.
Deliverable
Full-stack app running locally with login and role-based screens.
Weekly checkpoint
Trace a login request end to end on a diagram and find a CORS error cause.
You will be able to
Build a React front end with components, state, routing and forms that consumes a REST API. Build secure REST APIs with Spring Boot, JPA/Hibernate, validation, error handling and JWT-based authentication. Draw and explain client-server, API-flow and database architecture for the application.
Delivery and operations Weeks 20–21
Week 20: Docker and continuous integration
Theory
Containers, images and Dockerfiles for Spring Boot and React
Docker Compose with a database
Continuous integration with GitHub Actions: build and test on every push
Lab
Containerise the back end and front end, run all three services with Docker Compose and add a CI workflow that builds and runs the tests.
Homework
Make a test fail on purpose, see CI catch it and then fix it.
Deliverable
Dockerfiles, a compose file and a green CI run.
Weekly checkpoint
Read a Dockerfile and identify a problem such as a secret baked into an image.
You will be able to
Containerise with Docker, automate checks with CI and deploy the application with configuration kept outside the code.
Week 21: Deployment, configuration, logging and monitoring basics
Theory
Environment variables, profiles and secrets management
Deploying to a cloud platform or a virtual machine
Structured logging and health checks
Backups, database migrations in production and rollback thinking
Lab
Deploy the application with a managed or containerised database, set secrets through the platform and verify with a health endpoint and logs.
Homework
Write a one-page runbook: how to deploy, roll back and check health.
Deliverable
A deployed application URL and a runbook.
Weekly checkpoint
Read logs to find why a deployment fails and list what must never be committed to Git.
You will be able to
Containerise with Docker, automate checks with CI and deploy the application with configuration kept outside the code. Draw and explain client-server, API-flow and database architecture for the application.
AI-assisted development Weeks 22
Week 22: AI-assisted development with review and responsible use
Theory
Where AI helps: boilerplate, explanations, test ideas, refactoring suggestions
Where it fails: outdated APIs, invented methods, insecure code and confident errors
Verification: read, run, test, compare with documentation
Privacy, licensing and honesty: no secrets in prompts and recording where AI helped
Lab
Ask an assistant to generate a repository method and its tests; review for correctness, security and style, run them, and write a review note with at least three issues found or confirmed.
Homework
Evaluate honestly whether the assistant saved time on three tasks and note one task where it did not help.
Deliverable
An AI-use log and review notes attached to a pull request.
Weekly checkpoint
Review a prepared AI-generated controller and list its flaws, including an injection risk.
You will be able to
Use AI coding assistants responsibly: prompt precisely, review every suggestion, test it, protect private data and record where AI helped.
Capstone Weeks 23–24
Week 23: Capstone build sprint
Theory
Scoping: user stories and a minimum viable version
Task board, branching strategy and pull-request reviews
Definition of done: tests, documentation and deployment
Lab
Build the capstone features in two sprints with daily stand-ups; each feature gets a pull request, a test and a review.
Homework
Update the board and write acceptance criteria for the remaining features.
Deliverable
A working capstone with core features and tests merged to main.
Weekly checkpoint
Mid-point review: demo the working core and show test results.
You will be able to
Plan, build, present and document a capstone application as a small team or alone. Test across layers: unit tests with Mockito, API tests with MockMvc and manual checks with Postman.
Week 24: Capstone hardening, documentation and presentation
Theory
Security and performance review checklist
Writing a README, an API document and an architecture diagram
Demo and presentation skills; reflecting on lessons learned
Lab
Fix review findings, deploy the final version and rehearse a ten-minute demo with architecture diagram and live walkthrough.
Homework
Write a one-page reflection on what you would improve and where AI helped or misled.
Deliverable
Deployed capstone, repository, documentation and a recorded demo.
Weekly checkpoint
Final demo and viva by the review panel.
You will be able to
Plan, build, present and document a capstone application as a small team or alone. Containerise with Docker, automate checks with CI and deploy the application with configuration kept outside the code. Draw and explain client-server, API-flow and database architecture for the application. Use AI coding assistants responsibly: prompt precisely, review every suggestion, test it, protect private data and record where AI helped.
Sample lessons
Week 10
How a REST request travels: client, API and database
A web application splits into a client (the browser running React), a server (the Spring Boot API) and a database. The client sends an HTTP request such as GET /api/courses/3. The API's controller receives it, a service applies the business rules and a repository asks the database for the data. The result travels back as JSON with a status code like 200 or 404. Each layer has one job, which keeps code testable and makes errors easier to locate. Knowing this flow lets you debug any full-stack problem by asking where in the chain it failed.
1Browser (React) sends GET /api/courses/3
2Controller receives request
3Service applies rules
4Repository runs SQL
5Database returns the row
6API returns JSON with status 200
One request, five stops, one JSON response.
Step by step
Pick one user action, for example opening the course page.
Write the HTTP request: method, path, headers and body if any.
Follow it through controller, service and repository.
Write the SQL the repository runs and the JSON that comes back.
List the status codes for success, not found and invalid input.
In real life
When a student opens a course page on a training centre site, the browser asks the API for that course; the API loads it from the database and the browser displays the returned JSON as a page.
Worked example
Problem. A React page shows an empty course list although the database has data. Where do you look first?
Solution. Check the network tab: if the request returns 200 with data, the bug is in the React rendering or state. If it returns 401 or 403, check the token. If it shows a CORS error, fix the back end configuration. If it returns 500, read the Spring Boot logs and the SQL. Work through the chain from client to database and stop at the first failing layer.
Common mistakes
Putting database queries inside controllers instead of the repository layer.
Returning entities directly and exposing fields that should stay private.
Ignoring status codes and returning 200 for every error.
Try it yourself
Draw the request flow for creating a new student and list the status codes.
Explain which layer should check that a fee amount is not negative and why.
Week 22
Reviewing AI-generated code before you accept it
AI assistants can draft code quickly, but they can invent methods that do not exist, use outdated libraries, ignore validation or write insecure queries, and they sound equally confident when wrong. You remain responsible for every line you commit. A safe habit is a loop: give a precise prompt with context, read the result, run it, test it with normal and edge cases, check anything unfamiliar in the official documentation and only then commit with a note about where AI helped. Never paste passwords, API keys or customer data into a prompt. The honest question is whether the tool actually saved time on this task, or whether review cost more than writing it yourself.
1Prompt with context
2Read and understand
3Run and test
4Review security and docs
5Commit with a note
↻
The human stays responsible at every step.
Step by step
Write a prompt that states the language, framework version, input, output and constraints.
Read the whole answer and mark anything you do not understand.
Check unfamiliar methods and annotations in the official documentation.
Run it and add tests for normal, boundary and invalid input.
Review security: input validation, SQL parameters, secrets and authorisation.
Commit with a message and record the AI contribution in your log.
In real life
A developer asks an assistant for a student search endpoint. The result builds the SQL by joining the user's text into the query. A reviewer spots the SQL injection risk and replaces it with a parameterised JPA method before the code is merged.
Worked example
Problem. An assistant gives this code: @GetMapping("/students") public List<Student> find(@RequestParam String name) { return jdbc.query("SELECT * FROM students WHERE name = '" + name + "'", mapper); } What is wrong and how do you fix it?
Solution. The name is concatenated into the SQL, so a value like ' OR '1'='1 returns every row, which is SQL injection. Fix it with a parameter: jdbc.query("SELECT * FROM students WHERE name = ?", mapper, name), or use a JpaRepository method findByName(String name). Then add a test that passes a malicious string and checks that no extra rows come back.
Common mistakes
Accepting code because it compiles and runs once.
Pasting real keys or student data into a prompt.
Not checking whether a suggested library or method exists in the version you use.
Try it yourself
Ask an assistant for a DTO validation example, then list two things you verified in the documentation.
Write a three-line AI-use note for a pull request that states what was generated, what you changed and how you tested it.
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
In a restaurant, you give your order to the waiter, who takes it to the kitchen and brings the food back. In a web app, which part is like the waiter?
1Client (browser)
2Server / API
3Database
Projects
Training Centre Management System (capstone)
A small training centre in Madurai manages courses, students, enrolments and fee payments in notebooks. Build a full-stack web application where staff log in, manage courses and students, record enrolments and payments and view outstanding fees, and students view their own enrolments.
Tasks
Design the database schema with an ER diagram and migration scripts for courses, students, enrolments and payments.
Build secured Spring Boot REST APIs with validation, role-based access (ADMIN and STUDENT) and consistent error responses.
Build a React interface with login, course and student screens, enrolment and a fee-due report.
Write unit tests with Mockito and MockMvc tests for at least the enrolment and payment flows and run them in CI.
Containerise with Docker, deploy it and document the architecture, API and a deployment runbook.
Keep an AI-use log of where assistants were used and what you changed after review.
Sample input
POST /api/enrolments {"studentId": 12, "courseId": 3, "feePaid": 5000}
Expected output
201 Created with the enrolment JSON; the fee-due report shows the remaining balance for the student; an enrolment for a missing course returns 404 with a clear error body.
How it is assessed
Criterion
Weight
Working features and correct data handling
25%
API design, security and validation
20%
Front end quality and usability
15%
Tests and CI evidence
15%
Deployment, documentation and architecture diagram
15%
Responsible AI use and demo
10%
Stretch challenge: Add email-style payment reminders through a scheduled job and a dashboard chart of monthly collections.
Library Book Lending API (mid-course)
Build a Spring Boot REST API with a PostgreSQL database that manages books, members and lending for a school library, including due dates and a list of overdue books.
Tasks
Create entities and migrations for Book, Member and Loan.
Implement CRUD and the lend/return endpoints with validation.
Add an overdue report endpoint using a JPA query.
Write service and controller tests covering normal and error cases.
Sample input
POST /api/loans {"bookId": 4, "memberId": 9}
Expected output
201 Created with a due date 14 days ahead; a second loan of the same book returns 409 Conflict; /api/loans/overdue lists only loans past their due date.
How it is assessed
Criterion
Weight
Correct API behaviour
35%
Database design and migrations
25%
Validation and error handling
20%
Tests
20%
Stretch challenge: Add a fine calculation and a simple React screen listing overdue loans.
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 review of one pull request. Fortnightly: an architecture or API-flow diagram exercise.
Practical work. Learners submit code, SQL, test cases and diagrams in Git; trainers run the tests, read the history, question the learner on design choices and assess a live debugging task.
What trainers look for
Weight
Correctness and working features
30%
Code quality, design and security
20%
Tests and debugging evidence
20%
Architecture diagrams and documentation
15%
Responsible AI use and teamwork
15%
Where this can lead
Prepares you for junior Java and full-stack developer roles through a portfolio of deployed projects.
Builds the foundation for further study of microservices, cloud and DevOps.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
