Lộ trình ôn phỏng vấn Java Spring Boot + ReactJS

• OOP nâng cao: SOLID, composition vs inheritance, abstract class vs interface
• Pass by value vs pass by reference — Java truyền reference theo value
• Exception handling: checked/unchecked, try-with-resources
• String: String Pool, immutability, StringBuilder vs StringBuffer
• Java 8+ features: Lambda, functional interface, method reference, Stream API (lazy evaluation, parallel stream), Optional, default/static method trong interface, Date/Time API mới
• P0/P1 theo JD: Java 9-21: var, Record, Sealed class, pattern matching, virtual threads; hiểu khi nào nâng cấp runtime mang lại giá trị
• Collection Framework chuyên sâu: HashMap hoạt động thế nào (hash, bucket, collision, treeify từ Java 8), HashMap vs ConcurrentHashMap vs Hashtable, ArrayList vs LinkedList, fail-fast vs fail-safe iterator, hashCode()/equals() contract
• Concurrency & Multithreading: Thread lifecycle, synchronized, volatile, Lock/ReentrantLock, Atomic (CAS), ExecutorService, ForkJoinPool, race condition/deadlock/livelock
• Async trong Java: CompletableFuture, Future vs CompletableFuture, xử lý exception async
• Event-driven trong Java: khái niệm Event Bus, so sánh in-process event vs message broker
• JVM & Memory: Heap/Stack, GC cơ bản (G1), memory leak thường gặp, ClassLoader
• Độ phức tạp (Big O) của các thao tác Collection thường dùng

• Giải thích cơ chế HashMap khi resize, tại sao ảnh hưởng hiệu năng
• So sánh ArrayList với LinkedList; phân biệt HashMap, TreeMap và LinkedHashSet
• Functional Interface khác Anonymous Inner Class ở target typing, this, state và use case nào?
• Stream API hoạt động ra sao; khi nào vòng lặp truyền thống rõ ràng hoặc hiệu quả hơn?
• Garbage Collector xác định object có thể thu hồi thế nào; chọn collector theo throughput/pause SLO ra sao?
• Thiết kế giải pháp chống race condition cho giao dịch ngân hàng (optimistic lock @Version vs pessimistic lock SELECT FOR UPDATE)
• Giao dịch bị fail giữa chừng thì xử lý ra sao: rollback, idempotency key, retry với backoff, Saga/compensating transaction, outbox pattern
• Phân biệt sâu synchronized method vs synchronized block vs Lock
• Parallel Stream có luôn nhanh hơn Stream thường không, khi nào không nên dùng

• Implement optimistic locking cho transaction ngân hàng bằng JPA @Version, viết test multi-thread mô phỏng race condition
• Dùng CompletableFuture xử lý gọi song song nhiều service, gộp kết quả, xử lý lỗi từng nhánh
• Custom cache đơn giản dùng LinkedHashMap (LRU), so sánh với ConcurrentHashMap
• Viết chương trình minh họa deadlock rồi fix bằng lock ordering

• Red flag: thuộc API nhưng không giải thích complexity/thread-safety; dùng parallel stream hoặc virtual thread như tối ưu mặc định
• Done: giải thích bằng memory/thread model, viết được concurrent test và phân tích trade-off của collection/concurrency primitive

• P0: Testing pyramid; unit/integration/E2E; JUnit 5; Mockito; assertion; test double; FIRST principles
• P0: Spring Boot test slices: @WebMvcTest, @DataJpaTest, @SpringBootTest; Testcontainers
• P1: Contract test, mutation test, flaky test, coverage có ý nghĩa; static analysis và dependency scanning
• Maven/Gradle lifecycle, dependency management; Git branching, rebase/merge và code-review checklist

• Unit test khác integration test ở boundary nào; khi nào mock gây test sai lệch?
• Vì sao coverage cao không đồng nghĩa chất lượng cao? Cách test transaction, retry và concurrency?
• Thiết kế test strategy cho một REST API có database, Kafka và external payment gateway

• Test service bằng JUnit/Mockito; test repository với PostgreSQL Testcontainers; test API bằng MockMvc
• Tạo một flaky test rồi loại bỏ nguyên nhân; thêm quality gate cho build

• Red flag: mock mọi dependency, chỉ test happy path, dùng H2 thay thế mù quáng database production
• Done: giải thích được test boundary, chọn đúng test slice và viết được test failure/concurrency

• P0: IoC/DI, bean lifecycle/scope, AOP proxy; Spring MVC request lifecycle và exception handling
• P0: auto-configuration, starter, configuration properties, Actuator; Spring Data JPA và N+1
• P0: @Transactional: proxy, propagation, isolation, rollback rule và self-invocation
• P1: Spring Security filter chain; async execution; WebClient; WebFlux khi JD yêu cầu

• Spring Boot bổ sung gì cho Spring; auto-configuration được kích hoạt và override ra sao?
• Spring inject List<T> và Map<String, T> ra sao; kiểm soát thứ tự/candidate thế nào?
• @Transactional hoạt động qua proxy thế nào, nên đặt boundary ở đâu và vì sao?
• Bean lifecycle diễn ra theo thứ tự nào; dùng @PostConstruct/@PreDestroy có caveat gì?
• Tại sao singleton bean vẫn có thể không thread-safe? Vì sao self-invocation làm transaction mất hiệu lực?
• Chẩn đoán N+1, lazy loading ngoài transaction và circular dependency

• Xây REST API có validation, global error handling, profile/config và Actuator
• Tạo rồi sửa self-invocation và N+1; quan sát query và transaction boundary bằng log/test

• Red flag: học annotation thuộc lòng nhưng không giải thích proxy, lifecycle hoặc request flow
• Done: debug được transaction, bean wiring, query JPA và lỗi request xuyên suốt

• P0: ACID, isolation anomalies, MVCC, locking/deadlock; normalization và transaction boundary
• P0: B-tree/composite/covering index, EXPLAIN, join, connection pool, keyset pagination
• P1: replication, partitioning/sharding; SQL vs document/key-value/column/graph database; CAP thực tế
• P0: Redis structures, cache-aside, TTL/eviction, invalidation, stampede; Sentinel/Cluster ở mức khái niệm

• Chọn isolation level và locking strategy cho chuyển tiền hoặc trừ tồn kho
• Giải thích 1NF, 2NF, 3NF và khi nào denormalization đáng đổi lấy chi phí consistency
• Index hoạt động thế nào, khi nào planner dùng/bỏ index và chi phí đối với write/storage là gì?
• Isolation level ngăn anomaly nào; chọn mức phù hợp từ business invariant và retry cost ra sao?
• Thiết kế index và pagination cho bảng hàng chục triệu dòng; đọc một execution plan
• Khi nào chọn SQL/NoSQL; xử lý cache inconsistency và thundering herd như thế nào?

• Benchmark query trước/sau index; so sánh OFFSET với keyset pagination trên dữ liệu lớn
• Tích hợp Redis cache-aside, đo hit ratio và mô phỏng stampede/invalidation

• Red flag: xem index là miễn phí, nhầm consistency của DB với business invariant, cache không có invalidation plan
• Done: từ workload đề xuất được schema, index, transaction và cache trade-off

• P0: HTTP semantics, status code, idempotency, pagination/filter/sort, versioning, validation và error contract
• P0: TCP, DNS, TLS, reverse proxy, keep-alive, timeout và connection pool ở mức debug ứng dụng
• P0: authentication vs authorization; session/JWT/OAuth2/OIDC; token expiry/rotation/revocation
• P0: OWASP Top 10, CORS, CSRF, XSS, SQL injection, SSRF, rate limit; secrets và least privilege

• Thiết kế API tạo payment an toàn khi client retry; idempotency key được lưu và hết hạn thế nào?
• JWT có thực sự stateless không; access token và refresh token nên được bảo vệ ra sao?
• JWT gồm gì, signature bảo vệ gì và resource server bắt buộc validate những claim nào?
• Mô tả HTTPS/TLS handshake từ ClientHello, certificate validation đến session keys
• Debug request chậm từ browser qua proxy đến Spring Boot bằng timeout budget nào?

• Viết OpenAPI contract, error model nhất quán, cursor pagination và idempotent POST
• Bảo vệ API bằng Spring Security; thêm rate limit và test CORS/authorization/OWASP cases

• Red flag: dùng POST/200 cho mọi thứ, log token/PII, tin dữ liệu client, retry không idempotent
• Done: thiết kế được API contract có security, failure semantics và backward compatibility

• P0: scope, closure, hoisting, this, prototype; equality, immutability và module
• P0: event loop, microtask/macrotask, Promise, async/await, cancellation và error propagation
• P0: TypeScript type system, narrowing, generics, utility types, unknown vs any
• P1: debounce/throttle, browser storage, memory leak, bundling và web performance basics

• Dự đoán thứ tự output của đoạn code event loop và giải thích từng queue
• Structural typing có trade-off gì; khi nào generic tốt hơn union hoặc overload?
• Closure hoặc event listener gây memory leak trong ứng dụng thật như thế nào?

• Implement debounce/throttle và Promise combinators có typing/cancellation
• Chuyển một module JavaScript sang TypeScript strict, loại bỏ any

• Red flag: dùng TypeScript như annotation cho có, bỏ qua async error/cancellation
• Done: đọc được event-loop trace và thiết kế type an toàn cho API response/state

• P0: render/reconciliation, component lifecycle, state/effect mental model, controlled form và custom hook
• P0: dependency array, stale closure, cleanup, lifting/colocating state; error boundary
• P1: server state với TanStack Query; Context/Redux/Zustand; routing và authorization UI
• P1: profiling, memoization, code splitting, accessibility; React Testing Library và E2E

• Vì sao effect chạy lặp hoặc đọc state cũ; khi nào không cần useEffect?
• Phân biệt server state và client state; chọn Context, Redux hay query cache theo tiêu chí nào?
• Tìm nguyên nhân re-render và tối ưu mà không lạm dụng useMemo/useCallback

• Xây frontend typed cho API Spring: form, loading/error/empty state, cache invalidation và optimistic update
• Đo bằng Profiler; viết component/integration test và kiểm tra keyboard accessibility

• Red flag: đồng bộ mọi thứ bằng effect, duplicate server state, memo hóa không đo đạc
• Done: giải thích được render flow, state ownership, failure UX và test strategy

• P0: RabbitMQ exchange/queue/ack/nack/prefetch/DLQ; Kafka partition/group/offset/replication
• P0: delivery semantics, ordering scope, idempotent consumer, retry/backoff, poison message và schema evolution
• P1: Kafka transactions/exactly-once giới hạn ở đâu; consumer lag, rebalancing và throughput tuning

• Chọn Kafka hay RabbitMQ từ workload, ordering, retention và routing requirement
• Làm sao không mất message và không tạo side effect hai lần khi consumer crash?
• Partition key sai hoặc retry queue sai gây hotspot/order violation như thế nào?

• Publish/consume bằng Spring Boot, thêm idempotency store, retry topic/queue và DLQ
• Mô phỏng consumer crash/rebalance; quan sát lag và duplicate delivery

• Red flag: tuyên bố exactly-once cho toàn hệ thống, retry vô hạn, không version event schema
• Done: trình bày được failure timeline và recovery cho producer/broker/consumer

• P0: latency, partial failure, timeout/retry/backoff/jitter, circuit breaker, bulkhead và idempotency
• P0: service boundary, database per service, sync vs async; Saga, Outbox/Inbox và compensating action
• P1: API Gateway, service discovery, config; consistency model, clock/order và split-brain intuition
• P2: CQRS/Event Sourcing khi có requirement rõ ràng, không dùng như mặc định

• Thiết kế transaction Order–Payment–Inventory và phân tích từng điểm có thể fail
• Chọn service communication sync hay async; RestTemplate và WebClient khác nhau ở đâu?
• Retry ở nhiều tầng gây retry storm ra sao; đặt timeout budget và circuit breaker ở đâu?
• Khi nào modular monolith tốt hơn microservices? Chi phí vận hành nào thường bị bỏ quên?

• Tách hai service giao tiếp REST rồi chuyển một flow sang event + transactional outbox
• Fault injection: delay, duplicate, service down; chứng minh recovery và eventual consistency

• Red flag: distributed transaction chỉ bằng annotation, shared database, retry không idempotent
• Done: vẽ được state machine/failure matrix và giải thích trade-off consistency/availability

• P0: functional/non-functional requirements, capacity estimate, API/data model, component diagram
• P0: load balancing, caching, queues, replication/sharding, consistency, availability và backpressure
• P0: bottleneck/failure analysis, security, observability, rollout và cost awareness
• P1: trình bày evolution từ MVP đến scale thay vì nhảy thẳng vào kiến trúc phức tạp

• Thiết kế URL shortener, notification system, order/payment hoặc chat system
• Thiết kế workload read-heavy/write-heavy: caching, index, partitioning, queue và sync/async thay đổi ra sao?
• Nếu traffic tăng 10 lần, thành phần nào nghẽn trước và đo bằng tín hiệu nào?
• Trade-off giữa strong consistency, latency, availability và operational complexity

• Mỗi tuần làm hai đề có timer; lưu diagram, assumptions, estimates và quyết định kiến trúc
• Tự review bằng rubric: requirement, scale, data, API, failure, security, observability, trade-off

• Red flag: name-dropping công nghệ, không estimate, không nói failure hoặc migration path
• Done: dẫn dắt được buổi design và bảo vệ quyết định bằng requirement/number/trade-off

• P0: image/layer/container/network/volume; Dockerfile cache, multi-stage, non-root và signal handling
• P0: build reproducibility, image scanning, secret handling; Docker Compose cho local stack

• Tại sao container thoát chậm hoặc không nhận SIGTERM? Tối ưu image/build cache thế nào?
• Container khác VM ở isolation/resource model nào; dữ liệu stateful được xử lý ra sao?

• Dockerize Spring Boot và React/Nginx bằng multi-stage, healthcheck và non-root user
• Chạy full stack bằng Compose, kiểm tra network, persistent data và graceful shutdown

• Red flag: chạy root, bake secret vào image, dùng mutable tag, container giữ state quan trọng
• Done: build nhỏ, repeatable, secure và debug được startup/network/shutdown

• P0: Pod, Deployment, Service, Ingress; ConfigMap/Secret; requests/limits và scheduling basics
• P0: readiness/liveness/startup probes, rolling update, HPA, graceful shutdown và disruption
• P1: namespace/RBAC, Helm/Kustomize, stateful workload, network policy và troubleshooting flow

• Phân tích CrashLoopBackOff, OOMKilled, Pending hoặc service không route traffic
• Readiness khác liveness thế nào; rollout zero-downtime cần phối hợp app và cluster ra sao?

• Deploy stack lên minikube/kind với probes, resources, Ingress và HPA
• Thực hành failure drill: kill pod, bad config, OOM và failed rollout; dùng events/logs/describe để chẩn đoán

• Red flag: thiếu resource request, liveness gọi dependency ngoài, secret nằm trong Git
• Done: triển khai và debug workload bằng quy trình có hệ thống

• P0: trunk-based/Git Flow trade-off; merge/rebase; pipeline build-test-scan-package-deploy
• P0: artifact immutability, environment promotion, secret/OIDC, rollback; blue-green/canary
• P1: compute, object storage, managed DB, load balancer, IAM, VPC/subnet/security group, HA/DR
• P1: Infrastructure as Code, cost, backup/RPO/RTO và shared-responsibility model

• Thiết kế pipeline cho monorepo/microservices, tránh build/deploy nhầm và rollback an toàn
• Thiết kế cloud architecture multi-AZ; phân biệt scalability, availability, backup và disaster recovery

• GitHub Actions/Jenkins build, test, scan, push immutable image và deploy qua environment approval
• Deploy một phiên bản lên cloud/free tier hoặc mô tả IaC; diễn tập rollback

• Red flag: deploy lại artifact khác, long-lived cloud key, pipeline không rollback/audit
• Done: giải thích được supply chain từ commit đến production và blast radius của thay đổi

• P0: logs/metrics/traces; structured logging, correlation/trace ID; RED/USE method
• P0: SLI/SLO/error budget, alert quality, dashboard; incident triage và postmortem không đổ lỗi
• P1: OpenTelemetry, Prometheus/Grafana, ELK/OpenSearch; sampling và cardinality/cost
• P1: JVM/application signals: heap/GC/thread/CPU, pool saturation, latency percentile và queue lag

• P99 tăng nhưng CPU thấp: điều tra theo giả thuyết và tín hiệu nào?
• Trace một request xuyên service; phân biệt symptom alert với cause signal
• Thiết kế SLO và alert cho checkout/payment flow

• Instrument app bằng metrics, structured logs và distributed tracing; dựng dashboard tối thiểu
• Tạo latency/error/connection-pool incident rồi viết timeline, root cause và action items

• Red flag: log mọi thứ nhưng không correlation, alert theo CPU đơn lẻ, metric cardinality vô hạn
• Done: từ symptom thu hẹp được bottleneck và truyền đạt incident rõ ràng

• P0: STAR/CAR stories cho ownership, conflict, failure, ambiguity, mentoring và delivery pressure
• P0: code review, estimation, prioritization, technical debt, ADR và stakeholder communication
• P1: Agile/Scrum/Kanban/Waterfall trade-off; incident leadership và cross-team dependency
• Lead: tạo leverage qua standards, mentoring, delegation và decision-making thay vì chỉ code nhiều

• Kể một quyết định kỹ thuật sai, bạn phát hiện và sửa hậu quả như thế nào?
• Xử lý bất đồng giữa kỹ thuật và deadline; mentoring người yếu hơn mà vẫn bảo đảm delivery
• Ưu tiên feature, reliability và technical debt bằng dữ liệu nào?

• Chuẩn bị 6–8 câu chuyện STAR, mỗi câu có số liệu, vai trò cá nhân, trade-off và điều học được
• Mock interview có follow-up; ghi âm, cắt câu trả lời lan man và loại bỏ cách nói đổ lỗi

• Red flag: chỉ nói “team đã…”, không có kết quả đo được, biến conflict thành phàn nàn cá nhân
• Done: câu chuyện cụ thể, trung thực, thể hiện scope Senior/Lead và khả năng tự phản tỉnh

• Bài toán: hệ thống đặt hàng tối giản gồm 2 microservice độc lập — order-service (nhận đơn hàng) và payment-service (xử lý thanh toán), có 1 frontend ReactJS gọi vào
• Luồng chính (happy path): React gọi POST /orders → Order Service lưu đơn (status: PENDING) → gọi sang Payment Service POST /payments → Payment Service xử lý, trả kết quả → Order Service cập nhật status (CONFIRMED/FAILED) → trả về cho React
• Database per service pattern: mỗi service có DB riêng (order-db, payment-db) — không share database, minh họa đúng nguyên tắc microservices
• Giao tiếp: bắt đầu bằng REST đồng bộ (sync) cho đơn giản, sau đó (bước nâng cao) đổi Order→Payment sang bất đồng bộ qua Kafka/RabbitMQ để so sánh 2 cách tiếp cận

• Tạo order-service: entity Order, endpoint POST /orders, GET /orders/{id}, dùng Spring Data JPA + H2/PostgreSQL
• Tạo payment-service: entity Payment, endpoint POST /payments, giả lập xử lý thanh toán (random success/fail để test failure sau)
• Order Service gọi Payment Service bằng Feign Client hoặc WebClient (khuyến khích dùng Feign để thực hành declarative REST client — hay bị hỏi phỏng vấn)
• Áp dụng @Transactional đúng chỗ khi update status Order sau khi nhận response từ Payment (liên hệ Part 3 & 4)

• Timeout: cấu hình connect/read timeout khi Order gọi Payment
• Retry với exponential backoff (Resilience4j @Retry) khi Payment Service tạm thời lỗi
• Circuit Breaker (Resilience4j @CircuitBreaker): khi Payment Service down liên tục, mở circuit để tránh cascading failure, có fallback method trả response tạm (VD: "Payment pending, sẽ xử lý sau")
• Idempotency: thêm idempotency key vào request Payment để nếu Order retry, Payment không charge 2 lần (liên hệ bài toán "chống double transaction" ở Part 1)
• Nâng cao (optional): chuyển sang async qua Kafka — Order publish event OrderCreated, Payment consume và publish lại PaymentCompleted/PaymentFailed, áp dụng Saga pattern (compensating transaction: nếu Payment fail thì Order tự động chuyển CANCELLED)

• Form đặt hàng đơn giản gọi POST /orders, hiển thị trạng thái loading/success/error
• Polling hoặc gọi lại GET /orders/{id} để cập nhật status realtime (PENDING → CONFIRMED/FAILED)
• Xử lý UI khi backend trả lỗi/timeout — hiển thị thông báo rõ ràng cho user (liên hệ Part 7)

• Viết Dockerfile multi-stage cho order-service và payment-service (build bằng Maven/Gradle, runtime bằng JRE nhẹ)
• Viết Dockerfile cho React: build static files, serve bằng Nginx
• Viết docker-compose.yml chạy toàn bộ (2 backend + frontend + 2 database) chỉ với 1 lệnh docker compose up

• Viết Deployment + Service cho từng thành phần (order, payment, frontend)
• ConfigMap cho config không nhạy cảm, Secret cho DB credentials
• Ingress để route /api/orders → order-service, / → frontend
• Cấu hình readiness/liveness probe cho từng service (đặc biệt quan trọng để K8s biết khi nào Payment Service "chết" và không route traffic vào)
• Deploy thử lên minikube, test end-to-end: tạo đơn hàng qua frontend, xem log xử lý, thử tắt payment-service pod để quan sát circuit breaker + K8s tự restart pod

• Thêm API Gateway (Spring Cloud Gateway) đứng trước 2 service
• Thêm centralized logging/metrics/tracing (liên hệ Part 14), trace 1 request xuyên Order→Payment bằng correlation ID
• Thêm CI/CD pipeline tự build immutable image + deploy lên K8s khi push code (liên hệ Part 13)
• Thêm Redis cache cho GET /orders/{id} và giải thích invalidation strategy (liên hệ Part 4)

• Có unit/integration/E2E test cho happy path và failure path; hướng dẫn chạy local bằng một lệnh; không chứa secret
• Demo được timeout, duplicate request/message, service down và recovery; có log/metric/trace chứng minh hành vi
• Trình bày kiến trúc trong 10 phút: requirement, flow, data ownership, failure handling, security, observability và trade-off
• Tự chấm rubric 0–2 cho từng mục: correctness, testing, API/security, data, distributed failure, frontend UX, operations và communication

• Hiểu rõ async, non-blocking, event loop, Reactive Streams và backpressure.
• Xây và so sánh backend bằng Spring WebFlux và Vert.x.
• Thực hành capstone, failure handling và benchmark thay vì chỉ học API.

Khuyến nghị đã học Java Core, Spring Boot cơ bản, SQL, HTTP/API và các phần về distributed systems trong roadmap chính.

Course hub riêng gồm 16 module, source map chính thức, labs, capstones WebFlux/Vert.x và benchmark methodology.