A Java full stack skills checklist should show what you can build across the browser, API and database. Use the tasks below to find gaps in your preparation. This path uses React for the interface and Spring Boot for the backend; other frontend choices are possible.
Mark each area as need help, can build with documentation, or can build and explain independently. Keep a file, test or short demonstration for each completed task. These are practice milestones, not a guarantee of interview selection.
1. Core Java: model and test a small business rule
- Write classes with clear responsibilities, use interfaces where behaviour varies, and explain composition versus inheritance.
- Choose a List, Set or Map for a concrete task and explain duplicates, ordering and lookup needs.
- Validate input, handle an expected exception, read a stack trace and avoid empty catch blocks.
- Use generics, collections and streams without making a simple calculation hard to understand.
Evidence: an order-total calculator with tests for an empty order, invalid quantity and a valid discount. Calculate monetary amounts using a deliberate decimal representation and document the rounding rule.
2. SQL and persistence: explain where data is stored
- Create related product, order and order-item tables with primary and foreign keys.
- Write a join and a grouped total; explain how the result changes when no matching row exists.
- Use parameters for SQL input and explain why string concatenation is unsafe.
- Use a Spring Data repository while still being able to read the underlying table relationships.
- Show what happens when part of an update fails and explain the intended transaction boundary.
Evidence: a schema diagram, sample queries and a persistence test. Spring’s JPA guide demonstrates entities and repository interfaces; use it as a starting point, then add your own relationships and constraints.
3. Spring Boot: implement an API with predictable behaviour
- Trace a request through a controller, service and repository.
- Define request and response DTOs, validate inputs and return clear errors.
- Separate a missing record from invalid input and an unexpected server failure.
- Test one business rule independently and one HTTP request through the application.
- Keep database passwords and other secrets outside committed source files.
Evidence: an API collection containing successful create/read/update requests, malformed input and a missing ID. Record the expected status and response fields beside each request.
4. React and browser fundamentals: make the API usable
- Build a labelled form with HTML, CSS and JavaScript before relying on component libraries.
- Split the interface into components, pass data through props and manage changing data with state.
- Show loading, empty, success and error states when calling the backend.
- Prevent accidental repeat submissions in the interface and handle the server response.
- Check keyboard access, readable errors and the layout on a narrow screen.
Evidence: a task list with create/edit forms and a filter. React’s state-management guidance explains how to structure state and share it between components. Do not store a second copy of data that can be calculated from existing state without a reason.
5. Integration, access control and error handling
Choose one feature and follow it from a browser click to the saved row and back. Compare the browser request with the API contract. Check JSON field names, network failures and validation messages before adding more features.
- Test that one signed-in user cannot read or change another user’s private record by changing its ID.
- Enforce permission checks in the backend; hiding a button is only a user-interface choice. OWASP’s authorization guidance explains why checks must apply to each request.
- Configure the frontend’s allowed origin when cross-origin requests are needed. CORS controls browser access; it does not replace authentication or authorization.
- Keep technical exception details out of user-facing error messages.
Use the Spring MVC CORS documentation for the actual configuration. Choose the authentication method before deciding cookie, token and CSRF handling.
6. Git, testing and a reproducible demonstration
Make focused commits, review a diff, resolve a small merge conflict and provide a clean setup guide. Your README should list prerequisites, configuration names without secret values, database setup, test commands and known limitations. Confirm another checkout can run the application using that guide.
Final checkpoint: demonstrate one complete feature, one rejected request, one access-control check and one automated test. Explain a design choice you changed after finding a defect. Add cloud services or microservices only when the project needs them.
For a guided course covering the connected frontend, backend and database path, review Java Full Stack Development in Vizag at Softenant Technologies and compare its syllabus with the gaps in your checklist.