Spring Boot Java Backend Engineering

Implement interface-based polymorphism in a Java program.

Use composition to assemble behavior without unnecessary inheritance.

Model immutable data and finite states with records and enums.

Define and use a generic Java class or method.

Select and use List, Set, and Map implementations for a stated requirement.

Implement equals and hashCode correctly for a value object used in collections.

Distinguish checked exceptions, unchecked exceptions, and application errors.

Implement exception handling that preserves useful diagnostic context.

Represent potentially absent return values with Optional without misusing it.

Implement behavior with a lambda expression and a standard functional interface.

Transform collections using a readable Stream pipeline.

Represent timestamps and time zones correctly with the java.time API.

Execute tasks with ExecutorService while avoiding unsafe shared mutable state.

Manage dependencies and run build lifecycle tasks with Maven.

Use a feature-branch Git workflow to commit and merge a backend change.

Interpret the method, URL, headers, body, and status of an HTTP exchange.

Design resource-oriented REST endpoints with appropriate HTTP methods and status codes.

Model a relational schema using tables, primary keys, foreign keys, and constraints.

Write SQL queries that filter, aggregate, and join relational data.

Create and run a Spring Boot application with the required web dependencies.

Implement a Spring MVC controller that returns a JSON response.

Use Spring dependency injection to connect application components.

Separate controller, service, and repository responsibilities in a layered application.

Load environment-specific settings with Spring configuration properties and profiles.

Map between API data-transfer objects and domain objects without exposing internal entities.

Bind path, query, and request-body inputs in a Spring MVC endpoint.

Return explicit response statuses and headers with ResponseEntity and @ResponseStatus.

Validate incoming API data with Jakarta Bean Validation constraints.

Return consistent error responses through centralized exception handling.

Implement pagination and sorting for a collection endpoint.

Generate and inspect interactive API documentation with OpenAPI.

Apply idempotency principles to retry-sensitive API operations.

Connect a Spring Boot application to a PostgreSQL database.

Create and apply versioned database schema changes with Flyway.

Map a domain object to a database table with a JPA entity.

Model one-to-many and many-to-one relationships with explicit ownership.

Implement data access with Spring Data repository methods.

Define a transaction boundary for a multi-step business operation.

Identify and correct an N+1 query problem in a JPA use case.

Distinguish authentication from authorization in a backend security design.

Configure a Spring Security filter chain for public and protected endpoints.

Store user passwords safely with adaptive password hashing.

Issue and validate signed JSON Web Tokens using a security library.

Enforce role-based access rules at endpoint or method level.

Configure CORS and CSRF behavior for a stateless REST API.

Choose an appropriate unit, web-slice, repository, or integration test for a stated risk.

Write a JUnit test for a service-layer business rule.

Isolate a service test with Mockito test doubles.

Test controller behavior with MockMvc.

Test JPA mappings and queries against a real PostgreSQL test container.

Verify an end-to-end API workflow with a Spring Boot integration test.

Define the capstone's users, core use cases, and job-relevant scope.

Create an entity-relationship diagram for the capstone data model.

Specify the capstone REST contract before implementing its endpoints.

Scaffold the capstone using a maintainable package and layer structure.

Implement persistence for one complete capstone aggregate.

Implement service-layer rules for one complete capstone workflow.

Expose the workflow through validated, secured REST endpoints.

Verify the capstone's primary secured workflow with an integration test.

Add structured, request-aware application logs that support diagnosis of a failure.

Expose health information and application metrics with Spring Boot Actuator.

Build a container image for the Spring Boot application with Docker.

Run the application and PostgreSQL with Docker Compose using environment-based configuration.

Create a continuous-integration workflow that builds and tests each change.

Deploy the containerized capstone to a cloud hosting service.

Diagnose a failed deployment using configuration, health, and log evidence.

Document local setup, API usage, architecture, and trade-offs in a portfolio-ready README.

Explain JVM memory areas and the practical purpose of garbage collection.

Trace an HTTP request through Spring Security, controller, service, repository, and database layers.

Diagnose a representative Spring or JPA defect from an error message and code sample.

Solve an entry-to-associate-level array or hash-map problem in Java and justify its time and space complexity.

Complete and explain an interview-style SQL query containing a join and aggregation.

Present the capstone's architecture and trade-offs in a concise technical walkthrough.

Translate Unity development experience and capstone evidence into associate-backend résumé bullets and interview stories.