Requires Core Java: JDBC/SQL, Servlet/JSP basics, Spring Boot, REST APIs, JPA/Hibernate, Git/Maven, testing and a backend project.
What you will cover
Requires Core Java: JDBC/SQL
Servlet/JSP basics
Spring Boot
REST APIs
JPA/Hibernate
Git/Maven
testing
a backend project
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 5 stations. Each week builds one skill you can show, not just a topic you have heard.
1
Data layer: SQL, JDBC and the web container
Design a database, access it safely from Java and understand how servlets serve pages.
Week 1 SQL for backend developers
Week 2 JDBC and the DAO pattern
Week 3 Maven and Servlet/JSP basics
2
Spring Boot and REST
Build layered REST APIs with validation and consistent errors.
Week 4 Spring Boot foundations
Week 5 REST controllers
Week 6 Layers, DTOs, validation and errors
3
Persistence with JPA and Hibernate
Map entities, relationships and transactions with Spring Data JPA.
Week 7 JPA and Hibernate basics
Week 8 Relationships, queries and transactions
4
Team workflow and testing
Use Git and Maven and test the backend thoroughly.
Week 9 Git workflow and builds
Week 10 Testing backend applications
5
Backend project
Build, harden and present a backend application.
Week 11 Backend project: build
Week 12 Hardening and final demo
★
Campus Store Order API (Spring Boot, JPA, MySQL)
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
Design a relational schema and write SQL joins and aggregates for reporting.
Access MySQL from Java with JDBC and prevent SQL injection with parameterised queries.
Explain how a servlet container serves requests and build a basic Servlet/JSP page.
Build layered Spring Boot REST APIs with correct HTTP semantics, validation and error handling.
Map entities with JPA and Hibernate, handle relationships, transactions and the N+1 problem.
Use Git branches, pull requests and Maven builds in a team workflow.
Write unit and web-layer tests with JUnit, Mockito and MockMvc.
Deliver a documented backend project with a demo.
Who it suits
School Class 12 students with Core Java experience who want to see how real server-side applications are built.
College Final-year students who know Core Java and want a backend project for their portfolio.
Professional Working developers or career changers moving into Java backend roles.
Prerequisites: Core Java: OOP, collections, exceptions and basic file I/O. Completed Core Java or equivalent. Basic command line and Git installed. Tools: JDK 17 or 21 (LTS), IntelliJ IDEA Community or VS Code with Java extensions, Maven, JUnit 5, Git, MySQL Community Server and MySQL Workbench, Spring Boot 3.x via Spring Initializr, Postman or curl.
Weekly plan
Data layer: SQL, JDBC and the web container Weeks 1–3
Week 1: SQL for backend developers
Theory
Tables, keys and relationships
SELECT, JOIN and GROUP BY
Indexes and constraints
MySQL installation and tools
Lab
Install MySQL, design and create a shop database (products, customers, orders, order_items) with constraints, and write ten queries including joins and totals.
Homework
Draw an ER diagram for the campus store project.
Deliverable
schema.sql, seed data and a query sheet.
Weekly checkpoint
Predict query results; choose keys and constraints.
You will be able to
Design a relational schema and write SQL joins and aggregates for reporting.
Week 2: JDBC and the DAO pattern
Theory
Drivers, Connection, Statement and PreparedStatement
ResultSet mapping and transactions
DAO pattern and connection handling
SQL injection and how to prevent it
Lab
Write a ProductDao with create, read, update and delete using PreparedStatement; demonstrate SQL injection on a concatenated query, then fix it.
Homework
Add a transaction that moves stock between two products and rolls back on error.
Deliverable
ProductDao with a security note.
Weekly checkpoint
Spot unsafe SQL; order the steps of a JDBC query.
You will be able to
Access MySQL from Java with JDBC and prevent SQL injection with parameterised queries.
Week 3: Maven and Servlet/JSP basics
Theory
Maven project structure, pom.xml and lifecycle
How a servlet container handles requests
Servlets, request/response and JSP views
Forms and sessions at a basic level
Lab
Create a Maven web project, write a servlet that lists products from the DAO in a JSP and add a form to create a product.
Homework
Explain the request path from browser to JSP in a diagram.
Deliverable
Working Servlet/JSP product list.
Weekly checkpoint
Describe the servlet lifecycle; read a pom.xml dependency.
You will be able to
Explain how a servlet container serves requests and build a basic Servlet/JSP page.
Spring Boot and REST Weeks 4–6
Week 4: Spring Boot foundations
Theory
Spring Initializr and project layout
Inversion of control and dependency injection
Beans, configuration and application.properties
Profiles and logging
Lab
Generate a Spring Boot project, create a service bean injected into a controller, read a setting from application.properties and add a dev profile.
Homework
Explain constructor injection versus creating objects with new.
Deliverable
Running Spring Boot app with profile config.
Weekly checkpoint
Explain dependency injection with an example; locate a startup error.
You will be able to
Build layered Spring Boot REST APIs with correct HTTP semantics, validation and error handling.
Week 5: REST controllers
Theory
HTTP methods, status codes and JSON
RestController, PathVariable, RequestBody
Resource-oriented URL design
Testing with curl and Postman
Lab
Build an in-memory product API with GET, POST, PUT and DELETE; test each endpoint and record the status codes.
Homework
Design URLs and methods for customers.
Deliverable
Product API and a request/response log.
Weekly checkpoint
Match status codes; choose the right method and URL.
You will be able to
Build layered Spring Boot REST APIs with correct HTTP semantics, validation and error handling.
Week 6: Layers, DTOs, validation and errors
Theory
Controller, service and repository layers
DTOs and mapping
Bean Validation annotations
Central exception handling with ControllerAdvice
Lab
Refactor the API into layers with request/response DTOs, add validation for name and price, and return consistent JSON errors.
Homework
List five invalid requests and the status and message you would return for each.
Deliverable
Layered API with an error catalogue.
Weekly checkpoint
Choose 400 versus 404 versus 409; order a request through the layers.
You will be able to
Build layered Spring Boot REST APIs with correct HTTP semantics, validation and error handling.
Persistence with JPA and Hibernate Weeks 7–8
Week 7: JPA and Hibernate basics
Theory
Entities, @Id and column mapping
Spring Data JPA repositories
Derived queries and @Query
MySQL configuration and schema management
Lab
Replace the in-memory store with JPA entities and a repository connected to MySQL; add findByNameContaining and a custom query.
Homework
Compare the SQL you wrote in week 2 with the SQL Hibernate logs.
Deliverable
API persisting to MySQL with SQL logging evidence.
Weekly checkpoint
Read an entity class; choose repository methods.
You will be able to
Map entities with JPA and Hibernate, handle relationships, transactions and the N+1 problem.
Week 8: Relationships, queries and transactions
Theory
@ManyToOne and @OneToMany
Lazy and eager loading; the N+1 problem
JPQL, pagination and sorting
@Transactional
Lab
Add Order and OrderItem entities, list orders with customers, observe an N+1 query in the logs and fix it with a join fetch; add pagination.
Homework
Write down when a transaction is necessary in the order flow.
Deliverable
Order model with N+1 before/after evidence.
Weekly checkpoint
Identify N+1; predict what a rollback does.
You will be able to
Map entities with JPA and Hibernate, handle relationships, transactions and the N+1 problem.
Team workflow and testing Weeks 9–10
Week 9: Git workflow and builds
Theory
Branches, pull requests and merge conflicts
.gitignore and keeping secrets out of the repository
Maven profiles and building a runnable JAR
Commit message habits
Lab
Create two branches that edit the same line, resolve the conflict, tag a release and build the JAR; load the database password from an environment variable.
Homework
Write a team branching convention for the project.
Deliverable
Repository with history, a tag and a conflict-resolution note.
Weekly checkpoint
Order a pull-request workflow; resolve a conflict snippet.
You will be able to
Use Git branches, pull requests and Maven builds in a team workflow.
Week 10: Testing backend applications
Theory
JUnit 5 and AssertJ
Mockito for service tests
MockMvc for controllers and @DataJpaTest
Test naming and coverage
Lab
Write unit tests for the order service with a mocked repository, MockMvc tests for two endpoints and one repository test using an in-memory test database.
Homework
Add tests for three error cases (invalid input, missing id, out-of-stock).
Deliverable
Test suite that passes with mvn test.
Weekly checkpoint
Choose what to mock; read a failing test report.
You will be able to
Write unit and web-layer tests with JUnit, Mockito and MockMvc.
Backend project Weeks 11–12
Week 11: Backend project: build
Theory
Requirements and API design
OpenAPI documentation
Logging with SLF4J
Working in small, reviewed increments
Lab
Implement the Campus Store Order API endpoints for products, customers and orders with GST calculation and stock checks.
Homework
Update the API documentation and add log statements for key events.
Deliverable
Feature-complete API on a feature branch.
Weekly checkpoint
Code review of a classmate's pull request against a checklist.
You will be able to
Deliver a documented backend project with a demo.
Week 12: Hardening and final demo
Theory
Pagination, sorting and error cases
README and Postman collection
Performance check of slow queries
Demo and retrospective
Lab
Fix review comments, add pagination, profile one slow endpoint, finalise README and Postman collection and present a demo.
Homework
Write a short retrospective: what you would improve with more time.
Deliverable
Final project, demo and retrospective.
Weekly checkpoint
Project viva with scenario questions.
You will be able to
Deliver a documented backend project with a demo.
Sample lessons
Week 1
SQL joins for real reports
Relational databases keep data in separate tables to avoid repetition: customers in one table, orders in another. A join connects them using a key, usually a primary key in one table and a foreign key in the other. INNER JOIN keeps only matching rows; LEFT JOIN keeps every row from the left table even when there is no match, which is how you find customers who have never ordered.
customers.id
name
orders.customer_id
amount
1
Anu
1
500
1
Anu
1
200
2
Ravi
2
300
3
Meena
NULL
NULL
Step by step
Create customers(id, name) and orders(id, customer_id, amount).
Insert three customers and four orders; leave one customer without orders.
Write SELECT c.name, o.amount FROM customers c INNER JOIN orders o ON o.customer_id = c.id;
Change it to LEFT JOIN and notice the extra row with NULL.
Add GROUP BY c.name and SUM(o.amount) to produce a total per customer.
In real life
A shop keeps a customer register and a separate bill book. To see what each customer bought, you match the customer number written on each bill with the register.
Worked example
Problem. Customers: Anu, Ravi, Meena. Orders: Anu 500, Anu 200, Ravi 300. Which query lists customers with no orders?
Solution. SELECT c.name FROM customers c LEFT JOIN orders o ON o.customer_id = c.id WHERE o.id IS NULL; It returns Meena.
Common mistakes
Forgetting the ON condition, which produces every combination of rows.
Using INNER JOIN when the unmatched rows are exactly what you need.
Selecting columns with the same name from two tables without aliases.
Try it yourself
Write a query that shows each customer and the number of orders (0 included).
Find the customer with the highest total spend.
Explain why a foreign key helps data quality.
Week 5
Designing a REST endpoint with Spring Boot
A REST API exposes resources such as products through URLs and uses HTTP methods for actions: GET reads, POST creates, PUT or PATCH updates and DELETE removes. In Spring Boot a controller class maps a URL and method to a Java method, which calls a service and returns an object that Spring converts to JSON along with a suitable status code. Keeping the controller thin and the rules in a service makes the code easy to test.
Client: curl, browser, mobile app
Controller: URL + HTTP method
Service: business rules
Repository: database access
Step by step
Create a Product class with id, name and price.
Create ProductController annotated with @RestController and @RequestMapping("/api/products").
Add @GetMapping("/{id}") that calls productService.find(id).
Return 404 with a clear message when the product does not exist.
Add @PostMapping that validates the body and returns 201 with the saved product.
Call the endpoints with curl or Postman and compare the status codes.
In real life
A restaurant menu app calls the server to read the menu (GET) and to place an order (POST); the server answers with data and a status such as 201 Created.
Worked example
Problem. A client calls GET /api/products/99 and no product 99 exists. What should the API return?
Solution. Status 404 Not Found with a short JSON error such as {"message":"Product 99 not found"}. Returning 200 with an empty body would hide the problem.
Common mistakes
Putting database or business logic directly in the controller.
Returning 200 for every outcome, including errors.
Using verbs in URLs, such as /getProduct, instead of nouns and HTTP methods.
Try it yourself
Design the URLs and methods for customers: list, view, create, update, delete.
Add a query parameter ?minPrice= to filter products and test it.
Write the JSON body and expected status for a failed POST with a negative price.
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 · Table and row idea
A school keeps a table with columns Roll No, Name and Class. In a database, one row of this table represents…
Projects
Campus Store Order API (Spring Boot, JPA, MySQL)
Build a backend REST API for a campus store: products, customers and orders with 18% GST calculation. Use Spring Boot, Spring Data JPA with MySQL, Maven and Git, with validation, consistent error responses and automated tests.
Tasks
Design the schema (products, customers, orders, order_items) and draw an ER diagram.
Implement CRUD endpoints for products and customers with validation and correct status codes.
Implement POST /api/orders that checks stock, calculates GST and saves the order in one transaction.
Add a central exception handler that returns JSON errors with 400, 404 and 409 where suitable.
Write unit tests with Mockito for the order service and MockMvc tests for two controllers.
Document the API in a README with sample curl calls and keep the work in Git with meaningful commits.
Sample input
POST /api/orders {"customerId":1,"items":[{"productId":3,"qty":2}]}
Expected output
201 Created with the order total including 18% GST; stock reduced by 2; a request for more than the available stock returns 409 with a clear message.
How it is assessed
Criterion
Weight
Working endpoints and correct business rules
25%
Data model, JPA mapping and transactions
20%
Validation and error handling
15%
Automated tests
20%
Git history, README and build
20%
Stretch challenge: Add pagination and sorting for GET /api/products and an endpoint that returns monthly sales totals.
How you are assessed
Each week: a quiz mixing SQL result prediction, HTTP/REST scenarios and code reading, a lab committed to Git with a short note on what you observed in the logs.
Practical work. Practical assessment: run the API, call endpoints with Postman or curl, show passing tests, demonstrate one validation error and explain the SQL generated by JPA.
What trainers look for
Weight
Working endpoints and rules
30%
Database and JPA design
20%
Testing
20%
Error handling and security hygiene
15%
Git, documentation and explanation
15%
Where this can lead
Prepares you for junior Java backend and API development tasks.
Builds a Git-hosted backend project that you can explain in technical discussions.
These describe skills you will build. ADIVAS does not guarantee jobs, placement or salary.
Other programmes in Programming & Software Development
