Java Full Stack Development

Model immutable API and domain data with Java records.

Represent restricted domain state variants with sealed interfaces and pattern matching.

Implement stable equality and hashing for objects used in Java sets and maps.

Transform domain collections with streams without introducing side effects.

Design a consistent unchecked-exception hierarchy for a backend service.

Execute independent I/O tasks concurrently with Java 21 virtual threads.

Identify heap, stack, and metaspace responsibilities in a JVM memory diagram.

Diagnose a memory or garbage-collection symptom from a basic JVM log extract.

Create and run a Java 21 Spring Boot 3 service with Maven.

Trace how the Spring IoC container discovers, creates, and wires a bean.

Implement constructor-based dependency injection for an order-processing use case.

Organize a Spring Boot service into controller, application, domain, and infrastructure boundaries.

Bind and validate external configuration with Spring Boot configuration properties.

Separate local, test, and production settings with Spring profiles.

Inspect auto-configuration decisions in a Spring Boot application.

Expose application health and information through Spring Boot Actuator.

Map an order aggregate to PostgreSQL with JPA entities and value types.

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

Implement derived and custom queries with Spring Data JPA repositories.

Define a service-layer transaction boundary with `@Transactional`.

Eliminate an N+1 query detected in a JPA persistence flow.

Prevent lost updates with optimistic locking.

Version a PostgreSQL schema with Flyway migrations.

Persist and query a catalog document with Spring Data MongoDB.

Implement a Spring MVC endpoint using request and response DTOs.

Reject invalid API input with Jakarta Bean Validation.

Return consistent RFC 9457 problem details from centralized exception handling.

Implement pagination, filtering, and sorting with Spring Data.

Document and exercise an endpoint with an OpenAPI specification.

Unit-test a Spring service with JUnit 5 and Mockito.

Test the web layer with MockMvc and a Spring MVC test slice.

Run a PostgreSQL integration test with Testcontainers.

Trace an HTTP request through the Spring Security filter chain.

Configure endpoint authorization with a `SecurityFilterChain`.

Authenticate persisted users with `UserDetailsService` and BCrypt password hashing.

Issue a short-lived signed JWT with appropriate identity and authorization claims.

Validate bearer tokens with Spring Security's OAuth2 resource-server support.

Enforce role-based access with method security.

Configure and verify appropriate CORS and CSRF behavior for a stateless React client.

Verify login and protected-endpoint behavior with Spring Security test support.

Extract order, inventory, and notification boundaries from the project domain.

Implement a synchronous service call with Spring's `RestClient` and an explicit timeout.

Route external requests through Spring Cloud Gateway.

Publish a versioned order event with Spring for Apache Kafka.

Consume and validate an order event with a Kafka listener.

Make a Kafka consumer idempotent under duplicate delivery.

Implement a transactional outbox flow that atomically records an order event and relays it to Kafka.

Coordinate a failed order workflow with a compensating saga action.

Set an end-to-end timeout budget for a remote service call.

Apply retries only to operations that are safe to repeat.

Protect a failing dependency with a Resilience4j circuit breaker.

Limit abusive traffic at the API gateway.

Add correlation identifiers to structured application logs.

Publish application and business metrics with Micrometer.

Propagate distributed traces across two Spring services.

Diagnose a simulated production failure using logs, metrics, and traces.

Build a small non-root Java container image with a multi-stage Dockerfile.

Run the application, PostgreSQL, MongoDB, and Kafka with Docker Compose.

Deploy a Spring Boot service with Kubernetes Deployment and Service resources.

Inject runtime settings through Kubernetes ConfigMaps and Secrets.

Expose the application through a Kubernetes Ingress.

Configure startup, readiness, and liveness probes for Spring Boot.

Scale a service with resource requests, limits, and a Horizontal Pod Autoscaler.

Perform and reverse a rolling Kubernetes deployment.

Draw an EKS deployment topology that places load balancers in public subnets and application workloads and data stores in private subnets.

Design a least-privilege pod-level IAM role for a Spring workload running on EKS.

Connect a Spring Boot service to Amazon RDS for PostgreSQL with production connection-pool settings.

Connect a Spring Kafka client securely to Amazon MSK.

Store and retrieve order artifacts such as invoice files with Amazon S3 and AWS SDK for Java 2.x.

Load application secrets from AWS Secrets Manager without embedding credentials.

Route HTTPS traffic to EKS with the AWS Load Balancer Controller and an ACM certificate.

Route Spring Boot logs to CloudWatch Logs and configure alarms for key operational metrics.

Define build, test, package, and release stages in a declarative Jenkins pipeline.

Speed up a Jenkins build with Maven caching and parallel test stages.

Fail a pipeline on an automated quality or dependency-security check.

Manage deployment credentials with Jenkins credentials binding.

Tag and publish an immutable container image to Amazon ECR.

Deploy a selected image to Amazon EKS from Jenkins.

Trigger rollback when an EKS rollout fails its health checks.

Convert an ambiguous system-design prompt into functional requirements and service-level goals.

Estimate request throughput, storage growth, and peak capacity for an order platform.

Define APIs and data ownership for a scalable order-processing design.

Choose synchronous or asynchronous communication for each inter-service interaction.

Design a cache policy with explicit invalidation and failure behavior.

Choose consistency and transaction strategies for an order workflow.

Identify bottlenecks and propose horizontal-scaling and failure-recovery measures.

Deliver a structured 30-minute walkthrough of the project architecture and its trade-offs.

Solve a frequency-counting or deduplication problem with Java hash-based collections and justify the collection choice and complexity.

Solve a sorted-array problem with the two-pointer technique.

Solve a contiguous-subarray problem with a sliding window.

Solve a monotonic search problem with binary search.

Solve a top-k problem with a Java priority queue.

Solve a traversal problem with breadth-first or depth-first search.

Demonstrate a traced end-to-end order flow from the existing React client through the gateway, secured Spring services, persistence, and Kafka.

Present the move from Node.js to Java as an evidence-based mid-level engineering narrative without overstating professional Java tenure.