Interview study guide

Full cheat sheet — explain, compare, design, and code each topic

Target stack: Java + Spring Boot + REST + Microservices + AWS + Docker/Kubernetes + Kafka + SQL (PostgreSQL/MySQL) + React + CI/CD + System design

6-Week Study Calendar →

JavaSpring BootRESTMicroservicesAWSDocker/K8sKafkaSQLReactCI/CDSystem design
49
Jobs analyzed
35+
Topics covered
8
Week plan
7
Stack domains
For each topic below: Core concepts, Interview must-know questions, and Practice exercises — matching the full study guide.

Core stack demand

Job postings mentioning each skill (n=49)

Java
37 / 49
System design
30 / 49
REST APIs
30 / 49
AWS
26 / 49
Microservices
20 / 49
Kubernetes
20 / 49
CI/CD
20 / 49
Spring Boot
18 / 49
React
16 / 49
Kafka
14 / 49
PostgreSQL
8 / 49

Source: Jobs.xlsx · Aug 2026 · Y-axis = posting count (jobs)

Study time allocation

Suggested effort split (%)100% study time
25% Java+SQL15% Spring15% Arch20% Cloud10% Data8% FE7% Sec

Suggested study order (8 weeks)

WeekFocus
1Java core + collections + concurrency + SQL
2Spring Boot + JPA + REST + testing
3Microservices patterns + Kafka + Redis
4AWS (EC2, S3, RDS, Lambda) + Docker
5Kubernetes + Helm + CI/CD
6Security (OAuth2, JWT, Spring Security)
7React + TypeScript + Next.js basics
8System design drills + mock interviews

1. Languages

Java (must — deep)
Core
  • OOP: encapsulation, inheritance, polymorphism, abstraction; composition vs inheritance
  • == vs .equals() vs hashCode() contract
  • String, StringBuilder, StringBuffer; immutability
  • Generics: wildcards (? extends T, ? super T), type erasure, bounded types
  • Collections: List, Set, Map — ArrayList vs LinkedList, HashMap vs TreeMap vs ConcurrentHashMap
  • Streams API: map, filter, reduce, collect, parallel streams, lazy evaluation
  • Optional, records (Java 16+), sealed classes, pattern matching
  • Exception handling: checked vs unchecked, try-with-resources, custom exceptions
  • Memory model: stack vs heap, GC basics (Young/Old gen, G1, eligibility for GC)
  • Multithreading: Thread, Runnable, ExecutorService, Callable, Future, CompletableFuture
  • Concurrency: synchronized, volatile, ReentrantLock, ConcurrentHashMap, thread pools
  • Deadlocks, race conditions, visibility, happens-before
  • Java 8+: lambdas, functional interfaces, method references, default/static interface methods
Interview must-know
  • Implement thread-safe singleton
  • Explain HashMap internals (buckets, load factor, collision handling, Java 8 treeification)
  • Difference between HashMap and ConcurrentHashMap
  • Fail-fast vs fail-safe iterators
  • How GC works at a high level; memory leak causes in Java
  • SOLID principles with Java examples
Practice
  • Coding: two-sum, reverse linked list, valid parentheses, LRU cache, producer-consumer
  • Concurrency: implement a bounded buffer or rate limiter
  • Explain a bug involving shared mutable state
JavaScript
Core
  • Types: primitive vs reference; typeof, truthy/falsy
  • Scope: var vs let vs const; hoisting; closures
  • this binding: default, implicit, explicit (call/apply/bind), arrow functions
  • Prototypes and prototype chain; classes (syntactic sugar)
  • Event loop: call stack, task queue, microtask queue; setTimeout vs Promise
  • Promises: chaining, async/await, error handling
  • ES6+: destructuring, spread/rest, modules, template literals
  • Array methods: map, filter, reduce, find, some, every
  • Deep vs shallow copy; immutability patterns
Interview must-know
  • Explain closure with example
  • Event loop order (sync → microtasks → macrotasks)
  • == vs ===
  • Promise.all vs Promise.allSettled vs Promise.race
  • Debounce vs throttle
Practice
  • Flatten array, deep clone object, implement Promise.all, curry function
TypeScript
Core
  • Basic types, unions, intersections, literals, enums
  • Interfaces vs type aliases
  • Generics: functions, classes, constraints (extends)
  • Utility types: Partial, Required, Pick, Omit, Record
  • Narrowing: typeof, instanceof, in, discriminated unions
  • strict mode implications; any vs unknown vs never
  • Modules and configuration (tsconfig.json highlights)
Interview must-know
  • When to use interface vs type
  • How generics improve API design
  • Type-safe event handlers / API response typing in React
Practice
  • Type a REST API client; type React component props with optional/required fields
SQL
Core
  • DDL vs DML vs DCL
  • JOINs: INNER, LEFT, RIGHT, FULL, CROSS; self-join
  • Aggregations: GROUP BY, HAVING, window functions (ROW_NUMBER, RANK, LAG, LEAD)
  • Subqueries vs CTEs (WITH)
  • Indexes: B-tree basics, when indexes help/hurt, composite indexes, covering index
  • Constraints: PK, FK, UNIQUE, CHECK, NOT NULL
  • Normalization: 1NF–3NF; when to denormalize
  • Transactions: ACID; isolation levels; dirty read, phantom read
  • Query optimization: EXPLAIN/EXPLAIN ANALYZE, N+1 problem
  • Pagination: OFFSET vs keyset (cursor) pagination
Interview must-know
  • Write queries with JOINs + aggregation
  • Difference between WHERE and HAVING
  • How indexes work; why a query is slow
  • Explain transaction isolation with examples
Practice
  • Second highest salary, duplicate emails, running total, top N per group
  • Design schema for orders + order_items + customers
Python
Core
  • Data structures: list, dict, set, tuple; comprehensions
  • Functions: *args, **kwargs, decorators basics
  • OOP: classes, inheritance, dunder methods
  • Exception handling; context managers (with)
  • Modules and virtual environments
  • Typing basics; stdlib: json, datetime, collections, itertools
Interview must-know
  • List vs tuple vs set use cases
  • Mutable default argument pitfall
  • GIL (high level — why CPU-bound threading is limited)
  • Write script to parse JSON / automate a small task
Practice
  • Read file, count word frequency, simple REST call with requests
Go
Core
  • Goroutines and channels; buffered vs unbuffered
  • select statement; context cancellation (context.Context)
  • Structs, interfaces (implicit implementation), embedding
  • Error handling: return error vs panic/recover
  • Pointers; value vs reference receivers
  • Packages and modules (go mod)
  • Concurrency patterns: worker pools, fan-out/fan-in
Interview must-know
  • How goroutines differ from OS threads
  • Avoiding goroutine leaks
  • When to use mutex vs channel
  • Interface design in Go (accept interfaces, return structs)
Practice
  • Concurrent URL fetcher; rate-limited worker pool

2. Java Stack

Spring Boot
Core
  • Auto-configuration: @SpringBootApplication (component scan, @EnableAutoConfiguration)
  • Starters, DI, @Configuration, @Bean vs @Component
  • Profiles (application-dev.yml, @Profile)
  • Properties & externalized config; @ConfigurationProperties
  • Spring MVC: @RestController, @PathVariable, @RequestParam, @RequestBody
  • Validation: @Valid, Bean Validation (@NotNull, @Size, custom validators)
  • Exception handling: @ControllerAdvice, @ExceptionHandler
  • Actuator: health checks, metrics, readiness/liveness
  • Logging: SLF4J + Logback; correlation IDs
  • Layered architecture: Controller → Service → Repository
Interview must-know
  • Request lifecycle in Spring MVC
  • Constructor injection vs field injection (prefer constructor)
  • How to structure a REST API (DTOs, not exposing entities)
  • Transaction boundaries: @Transactional at service layer
  • Common pitfalls: self-invocation bypassing proxy, lazy loading outside transaction
Practice
  • Build CRUD API with validation + global exception handler
  • Add pagination, sorting, filtering
Spring Security
Core
  • Authentication vs authorization
  • Filter chain; where custom filters fit
  • UserDetailsService, PasswordEncoder (BCrypt)
  • JWT flow: login → issue token → validate on each request
  • Method security: @PreAuthorize, roles vs authorities
  • CORS and CSRF (cookie sessions vs stateless JWT)
  • OAuth2 Resource Server basics (JWT decoder, scopes)
Interview must-know
  • Stateless JWT architecture end-to-end
  • How to secure endpoints by role
  • Common vulnerabilities: SQL injection, XSS, broken auth
Practice
  • Secure Spring Boot API with JWT + role-based access
Hibernate / JPA
Core
  • Entity mapping: @Entity, @Id, @GeneratedValue, @OneToMany, @ManyToOne, @ManyToMany
  • Fetch types: LAZY vs EAGER; N+1 fixes (JOIN FETCH, @EntityGraph, batch size)
  • Cascade types; orphan removal
  • JPQL vs Criteria API vs native queries
  • Pagination with Pageable
  • First-level vs second-level cache (conceptual)
  • Optimistic (@Version) vs pessimistic locking
  • @Transactional propagation and isolation
Interview must-know
  • Explain N+1 with example and fix
  • Difference between persist, merge, detach
  • LazyInitializationException — cause and solutions
  • Mapping bidirectional relationships correctly (owning side)
Practice
  • Design entities for e-commerce order system; write queries with joins and pagination
JUnit / Mockito
Core
  • JUnit 5: @Test, @BeforeEach, @ParameterizedTest, assertions
  • Test pyramid: unit → integration → e2e
  • Mockito: @Mock, @InjectMocks, when/thenReturn, verify, ArgumentCaptor
  • Stubbing void methods, throwing exceptions
  • Testing Spring: @WebMvcTest, @DataJpaTest, @SpringBootTest
  • Testcontainers for DB/Kafka integration tests
Interview must-know
  • Unit test vs integration test
  • Mock vs stub vs fake
  • How to test a service that calls a repository and external API
  • Test coverage — critical paths and edge cases
Practice
  • Unit test service layer with mocked repository
  • Controller test with MockMvc
Maven / Gradle
Core
  • Project structure: src/main/java, src/test/java, resources
  • Dependencies: compile vs test vs runtime scopes (Maven)
  • Multi-module projects (conceptual)
  • Plugins: compiler, surefire, spring-boot-maven-plugin
  • BOM / dependency management; version conflicts
  • Build lifecycle: compile, test, package, install
  • Profiles and environment-specific builds
Interview must-know
  • How dependency resolution works
  • Difference between SNAPSHOT and release
  • Troubleshoot dependency conflict (mvn dependency:tree)

3. Architecture

Microservices
Core
  • Monolith vs microservices trade-offs (deployment, scaling, complexity, data consistency)
  • Bounded contexts (DDD light)
  • Service communication: sync (REST/gRPC) vs async (Kafka/events)
  • API Gateway, service discovery (Eureka/Consul), load balancing
  • Database per service; shared database anti-pattern
  • Saga pattern: orchestration vs choreography; compensating transactions
  • Circuit breaker, retry, timeout, bulkhead (resilience4j)
  • Idempotency keys for safe retries
  • Versioning and backward compatibility
  • Centralized config, externalized settings
Interview must-know
  • When NOT to use microservices
  • How to handle distributed transactions (avoid 2PC; use sagas/outbox)
  • Design order → payment → inventory flow across services
  • Handling partial failures
Practice
  • Draw architecture for 3–4 services with Kafka events and REST sync calls
  • Explain how you'd migrate a monolith module by module
REST API Design
Core
  • Resources, URIs, HTTP verbs (GET/POST/PUT/PATCH/DELETE)
  • Status codes: 200, 201, 204, 400, 401, 403, 404, 409, 422, 500
  • Idempotency: PUT/DELETE vs POST
  • Pagination, filtering, sorting conventions
  • HATEOAS (awareness)
  • Versioning: URL vs header
  • Error response format (consistent JSON structure)
  • Content negotiation; JSON best practices
  • Rate limiting, API documentation (OpenAPI/Swagger)
Interview must-know
  • Design REST API for a domain (users, orders, products)
  • POST vs PUT vs PATCH with examples
  • How to handle validation errors and conflict (409)
Practice
  • Design OpenAPI spec for 5–10 endpoints; explain auth and pagination
System Design
Core
  • Requirements: functional vs non-functional (scale, latency, availability, consistency)
  • Back-of-envelope: QPS, storage, bandwidth
  • Load balancers (L4 vs L7), reverse proxy
  • Caching: client, CDN, application, database; cache-aside, write-through, TTL, invalidation
  • DB scaling: read replicas, sharding, partitioning
  • CAP theorem; PACELC
  • Consistency models: strong, eventual
  • Message queues for async/decoupling
  • CDN, object storage for static/media
  • High availability, fault tolerance, multi-AZ
  • Observability: logs, metrics, traces
Also practice
  • Common designs to practice: URL shortener, rate limiter, notification system, e-commerce checkout, feed/timeline, chat/messaging, payment processing pipeline
Interview must-know
  • Always clarify requirements first
  • Draw boxes: client → LB → API → cache → DB → queue → workers
  • Discuss bottlenecks and failure modes
  • Trade-offs explicitly (I'd choose X because…)
Distributed Systems
Core
  • Clocks and ordering: logical clocks, vector clocks (awareness)
  • Leader election, consensus (Raft/Paxos awareness)
  • Split-brain, quorum
  • Exactly-once vs at-least-once vs at-most-once delivery
  • Outbox pattern, inbox pattern, transactional messaging
  • Distributed locks (and cautions)
  • Eventual consistency examples (DNS, Cassandra-style)
  • Backpressure
Interview must-know
  • Why distributed transactions are hard
  • How Kafka fits in event-driven architecture
  • Idempotent consumers

4. Cloud & DevOps

AWS (EC2, Lambda, S3, RDS, EKS)
EC2
  • Instances, AMIs, security groups vs NACLs
  • Public vs private subnets; bastion pattern
  • Auto Scaling Groups, launch templates
  • ELB/ALB basics
Lambda
  • Event-driven model; triggers (API Gateway, SQS, S3, EventBridge)
  • Cold starts, memory/timeout tuning
  • IAM role for Lambda
  • Lambda vs EC2 vs ECS/EKS — when to use what
S3
  • Buckets, objects, keys; storage classes (Standard, IA, Glacier)
  • Versioning, lifecycle policies
  • Pre-signed URLs; server-side encryption
  • Static website hosting; S3 as event source
RDS
  • Managed relational DB; Multi-AZ, read replicas
  • Backups, snapshots; parameter groups
  • Connection pooling from apps (RDS Proxy awareness)
EKS
  • Control plane vs worker nodes; kubectl basics
  • Deployments, Services (ClusterIP, NodePort, LoadBalancer)
  • Ingress controller; IRSA (IAM roles for service accounts)
  • Helm charts on EKS
Cross-cutting AWS
  • IAM: users, roles, policies (least privilege)
  • VPC: CIDR, subnets, route tables, IGW, NAT gateway
  • CloudWatch: logs, metrics, alarms
  • Secrets Manager / Parameter Store
  • SQS, SNS (with Lambda and microservices)
Interview must-know
  • Design highly available 3-tier app on AWS
  • Secure API: API Gateway + Lambda + RDS in private subnet
  • Cost vs ops trade-offs (serverless vs containers vs EC2)
Docker
Core
  • Images vs containers; layers; Dockerfile best practices
  • Multi-stage builds
  • CMD vs ENTRYPOINT; ENV, ARG, volumes, ports
  • Docker Compose for local multi-service setup
  • Container networking basics
  • Image tagging and registries (ECR, Docker Hub)
  • .dockerignore; non-root user in containers
Interview must-know
  • Optimize Dockerfile for Java/Spring (layer caching, JAR layering)
  • How to debug container that exits immediately
  • Difference between volume and bind mount
Practice
  • Dockerize Spring Boot app; compose with PostgreSQL + Kafka
Kubernetes
Core
  • Pods, Deployments, ReplicaSets, Services
  • ConfigMaps, Secrets
  • Probes: liveness, readiness, startup
  • Resource requests/limits (CPU/memory)
  • Namespaces; labels and selectors
  • Ingress; Horizontal Pod Autoscaler (HPA)
  • Rolling updates vs rollback
  • StatefulSets (when needed)
  • Jobs/CronJobs
  • kubectl: get, describe, logs, exec, apply
Interview must-know
  • What happens when a pod dies
  • How Service discovers pods
  • Config management without rebuilding image
  • 12-factor app on Kubernetes
Practice
  • Deploy Spring Boot + expose via Service + Ingress
  • Explain rollout strategy for zero-downtime deploy
CI/CD
Core
  • Pipeline stages: build → test → scan → deploy
  • Branch strategies: trunk-based vs GitFlow
  • Artifact repository (Nexus, ECR)
  • Environment promotion: dev → staging → prod
  • GitHub Actions / GitLab CI / Jenkins concepts
  • Pipeline as code (YAML)
  • Secrets in CI (never hardcode)
  • Blue/green, canary deployments
  • Database migrations in CI/CD (Flyway/Liquibase)
Interview must-know
  • Design pipeline for Java microservice to EKS
  • Where unit vs integration tests run
  • Rollback strategy on failed deploy
  • Feature flags vs branch deploys
Practice
  • Write sample GitHub Actions: Maven build, test, Docker push
Terraform
Core
  • Infrastructure as Code benefits
  • Providers, resources, variables, outputs
  • State file; remote state (S3 + DynamoDB lock)
  • Modules for reuse
  • plan vs apply; drift detection
  • Workspaces or separate dirs per env
  • IAM policies as code
Interview must-know
  • How Terraform fits in CI/CD
  • State locking importance
  • Module structure for VPC + EKS + RDS
Monitoring / Observability
Core
  • Three pillars: logs, metrics, traces
  • Structured logging (JSON); correlation/trace IDs
  • Metrics: RED (Rate, Errors, Duration), USE (Utilization, Saturation, Errors)
  • Dashboards and alerting (avoid alert fatigue)
  • Tools: CloudWatch, Prometheus/Grafana, Datadog, New Relic, OpenTelemetry
  • SLI, SLO, SLA; error budgets
  • Distributed tracing across microservices
Interview must-know
  • What to alert on vs what to dashboard
  • How to debug high latency in microservices (trace + logs)
  • Golden signals for a REST API

5. Data

Kafka
Core
  • Topics, partitions, offsets; key-based partitioning
  • Producers, consumers, consumer groups
  • Replication, ISR, leaders/followers
  • At-least-once, at-most-once, exactly-once (conceptual)
  • Retention, compaction
  • Schema Registry + Avro/JSON schemas (awareness)
  • Kafka vs traditional message queues (RabbitMQ)
  • Event-driven architecture patterns
  • Dead letter topics; retry strategies
Interview must-know
  • Why partition count matters for parallelism
  • Consumer rebalance; lag monitoring
  • Design: order created → payment processed → notification sent
  • Idempotent consumer implementation
Practice
  • Producer/consumer in Java (Spring Kafka)
  • Explain failure scenario and recovery
PostgreSQL
Core
  • Types, JSONB column usage
  • Indexes: B-tree, GIN (JSONB/full-text)
  • MVCC; vacuum/analyze (awareness)
  • Sequences vs UUID PKs
  • Foreign keys, constraints
  • EXPLAIN ANALYZE
  • Extensions (pg_trgm, citext) — awareness
  • Row-level locking; SELECT FOR UPDATE
Interview must-know
  • Optimize slow query
  • Migration strategy for zero-downtime column add
  • PG vs MySQL trade-offs
MySQL
Core
  • Storage engines: InnoDB vs MyISAM (InnoDB default)
  • Indexes, EXPLAIN
  • Replication: primary/replica
  • Transactions and isolation
  • Common tuning: buffer pool (awareness)
Interview must-know
  • When to choose MySQL vs PostgreSQL
  • Handle duplicate key, deadlock retry
Elasticsearch
Core
  • Index, document, shard, replica
  • Inverted index concept
  • Query DSL: match, term, bool, filter vs query context
  • Aggregations
  • Near real-time search; refresh interval
  • Use cases: full-text search, log analytics (ELK)
  • Sync from DB: CDC, dual-write pitfalls
Interview must-know
  • ES vs SQL for search
  • Mapping design for searchable product catalog
  • Why reindexing happens

6. Frontend

React
Core
  • Components: functional components, JSX
  • Props vs state; lifting state up
  • Hooks: useState, useEffect, useMemo, useCallback, useRef, custom hooks
  • Controlled vs uncontrolled inputs
  • Conditional rendering, lists and keys
  • Context API (when to use vs prop drilling)
  • React Router basics
  • Performance: memo, virtualization awareness
  • Error boundaries
  • Fetching data: loading/error states; React Query awareness
Interview must-know
  • useEffect dependency array pitfalls
  • Reconciliation and virtual DOM (high level)
  • How to structure components for a dashboard or form wizard
  • State management options: Context, Redux, Zustand — when which
Practice
  • Build todo app or paginated user list consuming your Spring API
TypeScript (Frontend)
Core
  • Strict typing for props, API responses, hooks
  • Discriminated unions for UI states: { status: 'loading' } | { status: 'success', data: T }
  • Generic components (e.g. Table<T>)
Next.js
Core
  • App Router vs Pages Router (know App Router basics)
  • Server Components vs Client Components
  • File-based routing; layouts
  • fetch in server components; caching/revalidation
  • API routes / Route Handlers
  • SSR vs SSG vs ISR — when to use
  • Environment variables (NEXT_PUBLIC_)
  • Middleware for auth redirects
Interview must-know
  • Why Next.js over CRA/Vite for production apps
  • SEO and performance benefits of SSR/SSG
  • Auth pattern: JWT in httpOnly cookie vs localStorage trade-offs
Practice
  • Simple Next.js app calling backend API with loading states

7. Security

OAuth2
Core
  • Roles: Authorization Server, Resource Server, Client
  • Grant types: Authorization Code (+ PKCE for SPAs), Client Credentials, Refresh Token
  • Access token vs refresh token
  • Scopes and least privilege
  • Spring Authorization Server / Keycloak awareness
Interview must-know
  • Full login flow for web app (authorization code + PKCE)
  • Machine-to-machine with client credentials
  • Token storage best practices
JWT
Core
  • Structure: header.payload.signature
  • Claims: sub, exp, iat, iss, roles/scopes
  • Signing: HS256 vs RS256
  • Validation steps: signature, expiry, issuer, audience
  • Stateless vs session trade-offs
  • Cannot revoke easily — mitigations (short TTL, refresh rotation, blocklist)
Interview must-know
  • Why not store JWT in localStorage (XSS)
  • How Spring Security validates JWT
  • Refresh token rotation
SSO / SAML
Core
  • SAML vs OAuth/OIDC — enterprise SSO vs modern API auth
  • IdP vs SP; assertions
  • OIDC layer on OAuth2 (ID token vs access token)
  • Common in enterprise: Okta, Azure AD, PingFederate
Interview must-know
  • When SAML is used vs OIDC
  • High-level SAML login flow (SP-initiated)
IAM Concepts
Core
  • Authentication vs authorization vs accounting
  • RBAC vs ABAC
  • Principle of least privilege
  • IAM in AWS: policies, roles, trust relationships
  • Service-to-service auth: mTLS, IAM roles, OAuth client credentials
  • Identity federation
Interview must-know
  • Design roles for admin/user/support in an app
  • Cross-service auth in microservices on AWS (IRSA, API keys vs OAuth)

8. Other Topics

ETL / Streaming Pipelines
Core
  • Batch vs stream processing
  • ETL vs ELT
  • Tools: Kafka Streams, Spark Structured Streaming, AWS Glue/Kinesis
  • Windowing: tumbling, sliding, session
  • Late-arriving data; watermarks (conceptual)
  • CDC (Debezium) from DB to Kafka
  • Data quality, schema evolution
  • Exactly-once in pipelines (idempotent sinks)
Interview must-know
  • Design pipeline: DB → Kafka → transform → warehouse/search index
  • Handle duplicate events downstream
Design Patterns / OOP
Core
  • Creational: Singleton, Factory, Builder
  • Structural: Adapter, Decorator, Facade, Proxy
  • Behavioral: Strategy, Observer, Template Method, Command, Chain of Responsibility
  • Enterprise: Repository, DTO, Service Layer, Unit of Work (JPA)
  • Distributed: Circuit Breaker, Saga, Outbox, CQRS (awareness), Event Sourcing (awareness)
  • SOLID — explain each with example
Interview must-know
  • When to use Strategy vs Factory
  • Repository pattern with Spring Data
  • Anti-patterns: God class, anemic domain model
GCP (basics)
Core
  • Compute Engine vs GKE vs Cloud Run
  • Cloud Storage (compare to S3)
  • Cloud SQL, Pub/Sub (compare to SNS/SQS/Kafka)
  • IAM: projects, roles, service accounts
  • BigQuery for analytics (awareness)
Interview must-know
  • GCP vs AWS equivalents (GKE↔EKS, GCS↔S3, Pub/Sub↔SQS/SNS)
  • When company is multi-cloud or GCP-specific
GraphQL
Core
  • Schema, types, queries, mutations, subscriptions
  • Resolvers; N+1 problem (DataLoader)
  • REST vs GraphQL trade-offs
  • Over-fetching vs under-fetching
  • Validation and error format
Interview must-know
  • When GraphQL is a good fit vs REST
  • How to secure GraphQL API
  • Pagination patterns (cursor-based)
RabbitMQ
Core
  • Exchanges: direct, topic, fanout, headers
  • Queues, bindings, routing keys
  • Acknowledgments, prefetch, durability
  • Dead letter exchanges (DLX)
  • RabbitMQ vs Kafka: messaging vs event log
Interview must-know
  • Work queue pattern for background jobs
  • Ensure message not lost (persistent messages + acks)
  • When to pick RabbitMQ over Kafka
WebSockets
Core
  • Full-duplex over single TCP connection
  • Handshake upgrade from HTTP
  • Use cases: chat, live notifications, dashboards
  • STOMP over WebSocket (Spring)
  • Scaling WebSockets: sticky sessions, Redis pub/sub bridge
  • SSE (Server-Sent Events) as alternative for one-way push
Interview must-know
  • WebSocket vs polling vs SSE
  • Auth for WebSocket connections
  • Handle disconnect/reconnect
Helm
Core
  • Charts: Chart.yaml, values.yaml, templates
  • Releases and revisions; helm install/upgrade/rollback
  • Templating with Go templates
  • Environments via values files (dev/staging/prod)
  • Dependencies between charts
Interview must-know
  • Helm vs raw kubectl manifests vs Kustomize
  • Promote release across environments
  • Manage secrets in Helm (external secrets operator awareness)

9. Core stack — integrated interview domains

Combined stack scenarios you should be ready to discuss end-to-end

Backend API (Java/Spring)A
  • Design and implement REST CRUD with validation, pagination, error handling
  • JPA entities, relationships, transactions, N+1 fixes
  • JWT-secured endpoints with roles
  • Unit + integration tests (JUnit, Mockito, MockMvc)
Microservices & EventsB
  • Split monolith into 2–3 services with clear boundaries
  • Sync REST for queries; Kafka for async events
  • Saga or outbox for cross-service consistency
  • Idempotent consumers; dead letter handling
  • Correlation IDs across services
Cloud Deployment (AWS + K8s)C
  • Dockerize Spring Boot; push to ECR
  • Deploy to EKS with Deployment, Service, Ingress
  • RDS PostgreSQL in private subnet; secrets from Secrets Manager
  • ALB + HTTPS termination
  • Health checks and rolling updates
Data LayerD
  • Schema design (normalized); indexes for hot queries
  • Migrations with Flyway/Liquibase
  • Read replica for read-heavy endpoints (conceptual)
  • Cache hot data (Redis) — cache-aside pattern
  • Kafka for domain events (order.created, payment.completed)
Frontend Integration (React/Next.js)E
  • Consume REST API; handle auth token/cookie
  • Forms, validation, error states, loading skeletons
  • TypeScript types matching API DTOs
  • CORS understanding (backend config)
DevOps & ReliabilityF
  • CI pipeline: build, test, scan, deploy
  • Monitor: logs (JSON), metrics (latency, error rate), alerts
  • Debug production incident: high latency, Kafka lag, DB pool exhaustion
System Design (full stack)G
  • Typical prompt: Design an e-commerce order system
  • API Gateway / BFF
  • Order, Payment, Inventory services
  • PostgreSQL per service
  • Kafka events between services
  • Redis cache for product catalog
  • S3 for invoices/images
  • React/Next.js frontend
  • Auth (OAuth2/JWT)
  • Observability and scaling bottlenecks

10. Quick revision checklist

Before an interview, confirm you can answer each question

AreaCan you…?
JavaExplain HashMap, concurrency, streams, SOLID?
Spring BootWalk through request lifecycle and @Transactional?
JPAFix N+1 and explain lazy vs eager?
RESTDesign resources, status codes, idempotency?
MicroservicesExplain saga, circuit breaker, database-per-service?
KafkaExplain partitions, consumer groups, delivery semantics?
SQLWrite JOIN + window query; explain indexes?
AWSDraw VPC app with ALB, EKS, RDS, S3?
Docker/K8sWrite Dockerfile; explain Deployment/Service/probes?
CI/CDDescribe pipeline stages and rollback?
ReactExplain hooks, state, data fetching patterns?
SecurityExplain OAuth2 code flow and JWT validation?
System designClarify requirements → estimate → diagram → trade-offs?
Revision todos
Review hands-on: build one portfolio project using the full core stack end-to-end.