Java Spring Framework

Decompose a financial platform into bounded contexts with explicit service and data ownership.

Implement an immutable Java 21 monetary value type that enforces currency-safe arithmetic.

Enforce balance, payment, and ledger invariants inside domain aggregates.

Trace an HTTP request through Spring MVC filters, the DispatcherServlet, interceptors, and controllers.

Diagnose Spring Boot auto-configuration decisions using the condition evaluation report.

Implement validated, type-safe external configuration with @ConfigurationProperties.

Choose between Spring MVC with virtual threads and WebFlux for a specified workload.

Design a PostgreSQL double-entry ledger schema with database-enforced integrity constraints.

Map a financial aggregate with Spring Data JPA without exposing persistence concerns to the domain model.

Place @Transactional boundaries around a financial use case and select the required propagation behavior.

Reproduce dirty reads, non-repeatable reads, and serialization conflicts under PostgreSQL transaction isolation levels.

Prevent lost updates with JPA optimistic locking and a version column.

Coordinate a high-contention financial update with pessimistic locking.

Create a backward-compatible PostgreSQL schema migration with Flyway.

Define an OpenAPI contract for a versionable payment-initiation endpoint.

Validate financial commands at the HTTP boundary with Jakarta Bean Validation.

Map domain failures to a consistent RFC 9457 Problem Details response.

Implement persistent idempotency-key handling for a payment command endpoint.

Call another service with Spring RestClient while preserving a strict domain boundary.

Prevent internal fields and sensitive financial data from leaking through API DTOs.

Distinguish domain events from integration events and commands in a financial workflow.

Design a backward-compatible Kafka event schema with explicit metadata and versioning.

Select Kafka topic partitions and message keys to preserve required ordering.

Configure a Spring Kafka producer for appropriate acknowledgment and idempotence guarantees.

Explain how consumer groups, partition assignment, and offsets determine processing behavior.

Implement a manual-acknowledgment Spring Kafka consumer with controlled offset commits.

Implement an inbox-based idempotent Kafka consumer.

Route repeatedly failing records through bounded retries to a dead-letter topic.

Atomically persist a domain change and an outbox record in one PostgreSQL transaction.

Publish pending outbox records to Kafka without losing unpublished changes.

Choose between saga choreography and orchestration for a specified financial workflow.

Model an orchestrated payment saga as explicit states and transitions.

Implement a compensating action for a partially completed payment saga.

Handle duplicate and out-of-order events without corrupting workflow state.

Build a reconciliation job that detects discrepancies between payment and ledger records.

Explain the limits of exactly-once processing and select end-to-end delivery semantics.

Create a threat model for a payment flow spanning HTTP, Kafka, PostgreSQL, and Kubernetes.

Configure a Spring Security resource server to validate JWT issuers, audiences, and authorities.

Implement service-to-service authentication with the OAuth 2.0 client-credentials flow.

Enforce role- and resource-based authorization with Spring method security.

Emit an auditable security event without exposing credentials or sensitive financial data.

Apply data minimization and masking rules to API responses and application logs.

Derive service timeout values from an end-to-end latency budget.

Apply bounded retries with jitter only to operations that are safe to repeat.

Configure Resilience4j circuit breakers and bulkheads around a failing dependency.

Run PostgreSQL and Kafka integration tests with Testcontainers.

Verify an outbound HTTP integration with a deterministic stub server.

Test saga compensation across a controlled mid-workflow failure.

Verify that event replay does not duplicate financial effects.

Emit structured logs with correlation identifiers across HTTP and Kafka boundaries.

Publish technical and financial business metrics with Spring Boot Actuator and Micrometer.

Propagate and inspect distributed traces with OpenTelemetry.

Build a RED-method dashboard for a Spring Boot microservice.

Define a service-level objective and alert from its error-budget consumption.

Diagnose a latency regression using metrics, traces, and Java Flight Recorder evidence.

Size a HikariCP connection pool from concurrency requirements and PostgreSQL limits.

Build a reproducible Spring Boot OCI image with buildpacks or a multi-stage Dockerfile.

Run a Spring Boot container as a non-root user with a read-only root filesystem.

Configure a Kubernetes Deployment and Service for a stateless Spring Boot microservice.

Externalize application configuration with Kubernetes ConfigMaps and Secrets.

Configure distinct startup, readiness, and liveness probes through Spring Boot Actuator.

Set CPU and memory requests and limits from measured application behavior.

Configure horizontal pod autoscaling from a suitable workload metric.

Package a Spring Boot service and its configuration as a parameterized Helm chart.

Deploy the financial microservice stack to a local Kubernetes cluster and verify an event-driven payment flow.

Apply least-privilege Kubernetes service accounts and RBAC permissions.

Restrict service communication with namespace-scoped Kubernetes NetworkPolicies.

Execute Flyway migrations as a controlled Kubernetes Job before application rollout.

Configure graceful Spring Boot shutdown for zero-downtime Kubernetes rolling updates.

Automate build, test, image scanning, and local-cluster deployment in a CI pipeline.

Inject a pod or dependency failure and verify recovery, observability, and reconciliation behavior.