Java Backend Microservices Development

Generate a Java 21 Spring Boot 3 service with a reproducible Maven or Gradle build.

Explain how inversion of control transfers object construction and wiring to the Spring container.

Register Spring beans using stereotype annotations and explicit @Bean methods.

Apply constructor injection to make service dependencies explicit and testable.

Distinguish singleton, prototype, and request bean scopes in a web application.

Diagnose missing, ambiguous, and circular Spring bean dependencies.

Bind validated, type-safe configuration using @ConfigurationProperties and environment profiles.

Inspect a Spring Boot auto-configuration decision to explain why a bean was or was not created.

Map create, read, replace, update, and delete operations to appropriate HTTP methods and status codes.

Model immutable API request and response DTOs with Java records without exposing persistence entities.

Validate request data with Jakarta Bean Validation and return field-level validation details.

Implement consistent error responses using a global Spring exception handler.

Implement pagination, sorting, and filtering without returning unbounded result sets.

Implement server-side idempotency-key storage and replay behavior for a write endpoint.

Evaluate URI, header, and media-type API versioning strategies for a compatibility requirement.

Generate and verify an OpenAPI contract for the capstone service.

Map a small domain aggregate with correct JPA association ownership and cascade behavior.

Implement Spring Data JPA repository queries and choose an appropriate entity, projection, or paginated return type.

Place a Spring transaction boundary around a business use case and explain the proxy behavior involved.

Reproduce a transaction anomaly and select an isolation level that addresses the stated consistency requirement.

Apply optimistic locking to prevent lost updates in a frequently read aggregate.

Detect and eliminate an N+1 query problem using SQL logging, fetch joins, or entity graphs.

Create an environment-safe Flyway migration that includes an index justified by a database query plan.

Size and monitor a JDBC connection pool for a given service workload and database connection limit.

Choose between unit, slice, integration, contract, and load tests for a stated failure risk.

Test a Spring MVC controller slice with MockMvc and mocked collaborators.

Test JPA mappings and queries against a real database using Testcontainers.

Verify a complete API-to-database use case with @SpringBootTest and Testcontainers.

Simulate an unavailable or malformed downstream HTTP service using WireMock.

Write black-box API assertions with REST Assured.

Verify service compatibility with a consumer-driven contract test.

Use k6 latency percentiles and error rates to identify an API performance regression.

Distinguish authentication, authorization, OAuth 2.0, and OpenID Connect responsibilities.

Trace an HTTP request through the Spring Security filter chain.

Configure a Spring Boot API as a JWT-protected OAuth 2.0 resource server backed by an external identity provider.

Validate JWT issuer, audience, expiry, and authorities before granting API access.

Configure an OpenID Connect client against a local identity provider and trace the authorization-code flow with PKCE used for browser SSO.

Apply the client-credentials flow to secure service-to-service communication.

Enforce role- and ownership-based authorization with method security.

Choose appropriate CORS and CSRF controls for a specified client and authentication mechanism.

Evaluate when a modular monolith is preferable to microservices for a stated product context.

Derive candidate service boundaries from business capabilities in the commerce capstone.

Apply the database-per-service rule and identify coupling caused by a shared database.

Choose synchronous HTTP or asynchronous events for a specific interservice interaction.

Define cross-cutting routing, rate-limiting, and security responsibilities for an API gateway.

Implement a synchronous service-to-service call using Spring RestClient or an HTTP interface, including error mapping and context propagation.

Select choreography or orchestration and model the compensation actions for a distributed saga.

Design inbox or deduplication controls for a retried distributed operation.

Derive a downstream timeout from an end-to-end latency budget.

Configure bounded retries with exponential backoff and jitter only for safe operations.

Apply a circuit breaker and explain each state transition during downstream failure.

Use bulkheads to prevent one failing dependency from exhausting shared resources.

Apply rate limiting at the correct edge or service boundary for a stated scenario.

Emit structured logs with trace and correlation identifiers across service calls.

Define service-level indicators from Micrometer latency, traffic, error, and saturation metrics.

Trace a cross-service request with OpenTelemetry to locate a latency bottleneck.

Choose topic partitions and message keys to meet an event-ordering requirement.

Implement a Spring Kafka producer with appropriate acknowledgements and idempotence, and handle publication results.

Implement a Spring Kafka consumer and choose offset-commit behavior that avoids message loss during failure or rebalancing.

Evolve an event schema while preserving backward compatibility for existing consumers.

Route transient and permanent consumer failures using bounded retries and a dead-letter topic.

Apply the transactional outbox pattern to publish database changes without a dual write.

Configure Kafka client authentication and transport encryption with SASL and TLS.

Interpret consumer lag, throughput, and error metrics to diagnose a slow consumer.

Build a small, reproducible Java container image with a multi-stage Dockerfile.

Configure the Java application container to execute under a dedicated non-root user.

Run and troubleshoot the capstone service, database, and Kafka dependencies with Docker Compose, environment variables, and health checks.

Distinguish Kubernetes Pods, Deployments, Services, and Ingress, and explain DNS-based service discovery.

Supply runtime configuration through ConfigMaps and sensitive values through Secrets.

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

Set resource requests and limits and explain their effect on scheduling and autoscaling.

Diagnose a failed Kubernetes rollout using status, events, and container logs.

Configure a CI pipeline to compile, test, and package a Spring Boot service.

Scan a container image for critical CVEs and remediate vulnerable base-image dependencies.

Sequence a backward-compatible database migration with an application release.

Compare rolling, blue-green, and canary deployment strategies for a release risk.

Select ECS or EKS for a stated team size, workload, and operational constraint.

Design centralized runtime configuration using AWS Systems Manager Parameter Store or AppConfig, including safe refresh behavior.

Assign least-privilege IAM roles and Secrets Manager access to a deployed service.

Use CloudWatch logs and metrics to diagnose a failed or unhealthy service deployment.

Turn an ambiguous backend design prompt into explicit functional and non-functional requirements.

Estimate request throughput, storage growth, and bandwidth for a service design.

Choose a database and caching strategy from access patterns and consistency requirements.

Design a scalable request path using load balancing, stateless services, and data partitioning.

Analyze a proposed architecture for bottlenecks, single points of failure, and degraded modes.

Produce a component and deployment diagram for the completed commerce microservice system.

Defend key capstone trade-offs in a timed microservice system-design discussion.

Present SAP Commerce experience as evidence of transferable Java backend skills using concise STAR stories.