IK
Interview Knowledge Book
Topics
Practice
Examples
Playground
RU
Recall loop
Practice
Start from all topics, a topic subtree, or a specific mode.
Topic
All topics
Computer Science and Algorithms
Big O notation
Time, space, and amortized analysis
Data structures
Arrays and dynamic arrays
Linked lists
Stacks, queues, and deques
Hash tables, maps, and sets
Trees and binary search trees
Heaps and priority queues
Tries
Graphs
Algorithms
Sorting algorithms
Searching and traversal
Two pointers
Sliding window
Prefix sums
Recursion and backtracking
Dynamic programming
Greedy algorithms
Topological sort
Dijkstra shortest paths
Interview task patterns
Arrays and strings tasks
Hash map task patterns
Tree and graph task patterns
Interval task patterns
Async JavaScript tasks
JavaScript utility implementation
JavaScript Core
Types and values
Primitive values
Object values
null vs undefined
Coercion and equality
Scope and execution
Lexical scope and closures
Hoisting and bindings
this, call, apply, and bind
Functions
Function declarations and expressions
Arrow functions
Higher-order functions
Pure functions, currying, and composition
Objects and prototypes
Prototype chain
Classes and constructors
Property descriptors and accessors
Object immutability
Async JavaScript
Event loop
Promises and async/await
Async errors and cancellation
Modules
ESM and CommonJS
Tree shaking and dynamic imports
Memory
Garbage collection
Memory leaks, WeakMap, and WeakSet
Browser and Node differences
Runtime APIs and globals
Module resolution
TypeScript
Basic TypeScript types
type vs interface
Union, intersection, and literal types
Optional and readonly fields
Type system
Generics and constraints
Narrowing and type guards
Discriminated unions
Utility and mapped types
Conditional and template literal types
Practical TypeScript
Strict mode and inference
unknown, any, and never
satisfies operator
Module augmentation
Typing API responses, React, and Node services
TypeScript tooling
tsconfig and project references
Declaration files and CI type checking
HTML, CSS, and Browser Platform
Frontend Frameworks
Testing, Design, and Architecture
System Design and Data
Tooling, Platform, and Process
Testing
Testing strategy
Test pyramid and risk-based coverage
Unit, integration, and E2E tests
Contract and component tests
Smoke and regression tests
JavaScript and TypeScript testing tooling
Vitest and Jest
Testing Library
Supertest and MSW
Playwright and Cypress
Pact and consumer-driven contracts
Backend testing
API tests
Database tests, containers, and transaction rollback
Mocks versus fakes
Frontend testing
Component behavior tests
Accessibility and visual regression checks
E2E user flows
Test quality
Arrange, Act, Assert and deterministic tests
Test data builders and fixtures
Avoiding brittle selectors
JUnit awareness for mixed stacks
Object-oriented programming
OOP foundations
Classes and objects
Encapsulation
Inheritance and polymorphism
Abstraction
OOP design principles
Composition over inheritance
Interfaces and contracts
Dependency injection
Immutability where useful
TypeScript OOP
Access modifiers
Abstract classes and interfaces
Decorators and metadata
Structural typing and OOP
Practical OOP trade-offs
When OOP fits JS and TS
OOP versus functional style
Domain models versus anemic models
SOLID, DRY, KISS, YAGNI, and related principles
SOLID principles
Single Responsibility Principle
Open/Closed Principle
Liskov Substitution Principle
Interface Segregation Principle
Dependency Inversion Principle
Other design principles
DRY
KISS
YAGNI
Separation of Concerns
Law of Demeter
High cohesion and low coupling
Applying design principles in practice
Recognizing overengineering
Explaining principle trade-offs
Showing a principle in code
When to break a principle
Clean Code
Readability
Naming
Function size
Module boundaries
Comments that explain why, not what
Maintainability
Refactoring
Duplication management
Error handling
Defensive programming
Code review
Architecture in code
Layering
Dependency direction
Public versus private API
Avoiding hidden side effects
Quality gates
Linters
Formatters
Static analysis
CI checks
Design Patterns
Creational patterns
Factory Method
Abstract Factory
Builder
Singleton
Prototype
Structural patterns
Adapter
Facade
Decorator
Proxy
Composite
Bridge
Behavioral patterns
Strategy
Observer
Command
State
Template Method
Chain of Responsibility
Iterator
Mediator
Frontend patterns
Container and presentational components
Compound components
Controlled components
Hooks as behavior reuse
Provider pattern
Backend patterns
Repository
Unit of Work
Service Layer
DTO
Dependency Injection
Middleware
Application Architecture
Architecture styles
Monolith
Modular monolith
Microservices
SOA
Event-driven architecture
Serverless
Layered architecture
Hexagonal architecture
Clean Architecture
Onion Architecture
Domain modeling
DDD basics
Entities
Value objects
Aggregates
Bounded contexts
Domain events
Frontend architecture
Feature-Sliced Design
Component architecture
Design system
BFF pattern
Micro-frontends
Architecture trade-offs
Coupling
Cohesion
Deployment complexity
Team boundaries
Operational cost
Migration strategy
Microservices and distributed systems
Service decomposition
Bounded contexts
Database per service
Shared kernel risks
Service ownership
Communication
Sync HTTP and gRPC
Async messaging
Events vs commands
Request-reply
Data consistency
Eventual consistency
Distributed transactions
Saga pattern
Outbox pattern
Inbox pattern
Idempotency
Resilience
Timeouts
Retries
Exponential backoff
Circuit breaker
Bulkhead
Fallbacks
Health checks
Operations
Service discovery
Configuration
Distributed tracing
Centralized logging
Versioning
Backward compatibility
Microservice patterns
API gateway
BFF
CQRS
Event sourcing
Strangler fig
Sidecar
Kafka, RabbitMQ, and messaging
Messaging basics
Queue
Topic
Exchange
Producer
Consumer
Consumer group
Publish-subscribe
Backpressure
Kafka
Kafka topics
Kafka partitions
Kafka replication
Kafka offsets
Kafka consumer groups
Kafka retention
Kafka compaction
Kafka delivery semantics
Kafka ordering guarantees
Kafka schema registry
RabbitMQ
RabbitMQ exchanges
RabbitMQ queues
RabbitMQ bindings
RabbitMQ routing keys
RabbitMQ acknowledgements
RabbitMQ dead-letter exchange
RabbitMQ prefetch
RabbitMQ work queues
Reliability patterns
Retry queues
Dead-letter queues
Idempotent consumers
Poison messages
Exactly-once as a practical trade-off
When to choose what
Kafka for event streaming and replay
RabbitMQ for task queues and flexible routing
Redis Streams and pub/sub for simpler cases
System Design
Interview flow
Requirements
Functional requirements
Non-functional requirements
Constraints
Traffic estimates
Storage estimates
API sketch
High-level design
Data model
Bottlenecks
Trade-offs
Scalability
Horizontal scaling
Vertical scaling
Load balancing
Sharding
Replication
Partitioning
Caching
Client cache
CDN cache
Application cache
Database cache
Cache invalidation
Cache-aside
Write-through
Write-behind
Reliability
Availability
Durability
Fault tolerance
Disaster recovery
RTO / RPO
Consistency
CAP theorem
Strong consistency
Eventual consistency
Read-after-write consistency
Common designs
URL shortener
Chat
Notification system
News feed
File upload service
Rate limiter
Search autocomplete
Collaborative editor basics
HTML
Semantic HTML
Document structure and metadata
Landmarks and headings
Lists and tables
HTML forms
Native controls and validation
Labels, names, and autocomplete
HTML media
Images and responsive media
Video and audio
SEO basics
Meta tags and Open Graph
Structured data
Accessibility basics
Keyboard navigation and focus
Native semantics before ARIA
CSS
CSS core concepts
Cascade
Specificity
Inheritance
Box model
Stacking context
Containing block
CSS layout
Flexbox
Grid
Positioning
Responsive design
Container queries
Styling architecture
BEM
CSS Modules
CSS-in-JS
Tailwind CSS
Design tokens
Modern CSS
Custom properties
Logical properties
Media queries
Animations and transitions
:has selector
@layer
CSS performance
Critical CSS
Layout thrashing
Repaints and reflows
Browser Platform
DOM
DOM tree
Event propagation
Event delegation
Custom events
Rendering pipeline
Parse HTML and CSS
Style calculation
Layout
Paint
Composite
Web APIs
Fetch API
Web Storage
IndexedDB
Service Workers
Web Workers
IntersectionObserver
ResizeObserver
BroadcastChannel
Web Crypto
Browser security
Same-origin policy
CORS
Content Security Policy
Cookies
Storage security
Browser performance
Core Web Vitals
Lazy loading
Code splitting
Resource hints
Browser caching
React
React basics
Components
Props
State
JSX
Rendering lists
Conditional rendering
Hooks
useState
useEffect
useMemo
useCallback
useRef
useReducer
Custom hooks
Rendering model
Reconciliation
Keys
Controlled vs uncontrolled components
Strict Mode
Concurrent rendering concepts
Component design
Composition
Compound components
Render props
Container and presentational split
Error boundaries
Forms
Native forms
React Hook Form
Validation
Server actions where applicable
Data fetching
Client-side fetching
Cache invalidation
Optimistic updates
React Query / TanStack Query
SWR
Testing React
Testing Library
Component tests
Accessibility-oriented queries
Performance
Avoiding unnecessary renders
Memoization
Virtualization
Bundle splitting
Next.js
Routing
App Router
Pages Router legacy knowledge
Dynamic routes
Route groups
Middleware
Rendering strategies
SSR
SSG
ISR
CSR
Streaming
Partial prerendering concepts
Server and client boundaries
Server Components
Client Components
Server Actions
Data fetching on the server
API surface
Route handlers
BFF pattern
Authentication integration
Production concerns
Caching
Revalidation
Image optimization
Metadata
SEO
Deployment on Vercel or custom Node runtime
State Management
General principles
Local vs global state
Server state vs client state
Derived state
Normalization
Immutability
Redux
Store
Actions
Reducers
Selectors
Middleware
Redux Toolkit
Redux Toolkit Query
MobX
Observables
Actions
Computed values
Reactions
Zustand
Store slices
Selectors
Persist middleware
Data fetching state
TanStack Query
SWR
Cache invalidation
Optimistic UI
Vue, Nuxt, and Angular
Vue
Composition API
Options API
Vue reactivity
Vue Router
Pinia
Nuxt
File-based routing
SSR and SSG
Data fetching
Nitro server
Angular
Components
Services
Dependency injection
RxJS
Forms
Routing
Node.js, APIs, and Security
Node.js
Node runtime
Node event loop
libuv basics
Streams
Buffers
Timers
Worker threads
Cluster
Modules and packages
ESM vs CommonJS
Module resolution
Package exports
npm scripts
Backend fundamentals
Request lifecycle
Middleware
Error handling
Validation
Logging
Configuration
Environment variables
Graceful shutdown
Node performance
CPU-bound vs I/O-bound work
Backpressure
Profiling
Memory leaks
Node security
Dependency vulnerabilities
Secrets handling
Input validation security
Backend Frameworks
Express
Express routing
Express middleware
Express error middleware
Express validation
Express security middleware
Testing Express with Supertest
NestJS
NestJS modules
NestJS controllers
NestJS providers
NestJS dependency injection
NestJS guards
NestJS interceptors
NestJS pipes
NestJS filters
NestJS CQRS module
NestJS microservices module
NestJS testing module
Fastify
Fastify plugins
Fastify schema validation
Fastify performance model
API Design
REST API design
REST resources and methods
REST status codes
Pagination, filtering, and sorting
Versioning and compatibility
REST idempotency
REST error response shape
OpenAPI contracts
GraphQL API design
GraphQL schema and operations
Resolvers, N+1, and DataLoader
Federation and query complexity
Realtime and streaming APIs
WebSocket APIs
SSE and long polling
WebRTC API basics
RPC, gRPC, and tRPC
RPC and gRPC contracts
tRPC API boundaries
Webhooks and event-driven APIs
API quality
Rate limits and API auth
Documentation and contract testing
HTTP and Networking
Networking basics
TCP and UDP
DNS resolution
TLS and certificates
IP addressing and ports
HTTP protocol
HTTP versions
HTTP methods and status codes
Headers and cookies
Caching and compression
Keep-alive and connection reuse
Browser networking
CORS and preflight requests
SameSite cookies
Mixed content
Proxies and gateways
Forward and reverse proxies
Load balancers
API gateway at the network edge
Nginx, Edge, and API Gateway
Nginx basics
Nginx reverse proxy and static serving
Nginx load balancing and TLS termination
Nginx compression and caching
Nginx rate limiting and request buffering
Edge concerns
CDN and cache-control
Edge redirects and functions
WAF and edge protection
API gateway operations
API gateway routing and auth delegation
API gateway limits and request transformation
API gateway observability
Auth and Security
Authentication
Sessions and cookies
JWT, OAuth, OpenID Connect, and SSO
MFA, password hashing, and refresh token rotation
Authorization
RBAC, ABAC, and ACL
Policy-based and multi-tenant authorization
Web security
XSS, SQL injection, and NoSQL injection
CSRF, SSRF, and clickjacking
CORS, CSP, and secure headers
Application security
OWASP, secrets, and dependency scanning
Input validation, output encoding, and file upload security
Rate limiting and audit logs
Databases and Storage
SQL fundamentals
Tables
Primary keys
Foreign keys
Joins
Indexes
Transactions
Isolation levels
Locks
Query plans
Normalization
Denormalization
PostgreSQL
Index types
JSONB
CTE
Window functions
Full-text search
Extensions
Vacuum basics
MySQL
Storage engines
Indexes
Transactions
Replication basics
SQLite
Embedded database use cases
Local-first apps
Limitations
MongoDB
Documents
Collections
Indexes
Aggregation pipeline
Schema design
Transactions
Redis
Strings
Hashes
Lists
Sets
Sorted sets
Streams
TTL
Pub/sub
Caching patterns
Distributed locks caveats
Search engines
Elasticsearch
OpenSearch
Full-text search
Inverted index
Vector storage
Embeddings
Similarity search
ANN indexes
RAG basics
pgvector
Pinecone / Weaviate / Qdrant
Data engineering basics
OLTP versus OLAP
Migrations
Backups
Replication
CDC
ETL and ELT pipelines
Data quality and lineage
ORM and Data Access
General data access concepts
Active Record vs Data Mapper
Repository pattern
Unit of Work
Query builder
Migrations
Lazy vs eager loading
N+1 queries
Transactions
Mongoose
Schemas
Models
Validation
Middleware
Population
Prisma ORM
Schema
Client
Migrations
Relations
Transactions
Drizzle ORM
SQL-like query builder
Schema definitions
Migrations
MikroORM
Identity map
Unit of Work
Entity manager
TypeORM
Entities
Repositories
Migrations
Query builder
Build Tools and JavaScript Tooling
Package managers
npm
pnpm
Yarn
Lockfiles
Workspaces
Bundlers and compilers
Vite
Webpack
Rollup
esbuild
SWC
Babel
Rspack
Turbopack
Code quality tooling
ESLint
Prettier
Biome
Husky
lint-staged
Monorepos
npm/pnpm/yarn workspaces
Turborepo
Nx
Dependency graph
Build caching
Release tooling
Semantic versioning
Changesets
Conventional commits
Git
Git basics
Commit
Branch
Merge
Rebase
Cherry-pick
Stash
Tag
Remote
Git collaboration
Pull request
Code review
Conflict resolution
Feature branches
Trunk-based development
GitFlow basics
Debugging and history
git log
git diff
git blame
git bisect
Reflog
Git quality practices
Atomic commits
Good commit messages
Release tags
CI/CD
CI basics
Install
Lint
Typecheck
Tests
Build
Artifacts
CD basics
Environments
Secrets
Deployment strategies
Rollbacks
Feature flags
CI/CD tools
GitHub Actions
GitLab CI
CircleCI
Jenkins
Argo CD
Pipeline quality
Caching
Parallel jobs
Matrix builds
Required checks
Preview deployments
DevOps
Docker
Images
Containers
Dockerfile
Layers
Multi-stage builds
Volumes
Networks
Docker Compose
Kubernetes
Pod
Deployment
Service
Ingress
ConfigMap
Secret
Namespace
HPA
Helm basics
Infrastructure as Code
Pulumi
Terraform
IaC state management
IaC environments
Runtime operations
Health checks
Readiness / liveness probes
Logs
Metrics
Alerts
Incident basics
Cloud Services
AWS
EC2
ECS / EKS
Lambda
S3
RDS
DynamoDB
SQS
SNS
CloudFront
IAM
CloudWatch
Google Cloud / GCP
Compute Engine
Cloud Run
GKE
Cloud Functions
Cloud Storage
Cloud SQL
Pub/Sub
IAM
Cloud Logging
Azure
App Service
Functions
AKS
Blob Storage
Azure SQL
Cosmos DB
Service Bus
Entra ID
Cloudflare
DNS
CDN
WAF
Workers
Pages
R2
D1
KV
Durable Objects
Cloud fundamentals
IAM
VPC / networking
Managed databases
Object storage
Queues
Serverless
Cost awareness
Observability
Logging
Structured logs
Log levels
Correlation IDs
PII-safe logging
Metrics
RED metrics
USE metrics
Business metrics
Prometheus basics
Tracing
Distributed tracing
Spans
Trace IDs
OpenTelemetry
Alerting
SLO
SLA
Error budget
Alert fatigue
Tools
Grafana
Prometheus
Loki
Datadog
Sentry
New Relic
Performance
Frontend performance
Core Web Vitals
Bundle size
Code splitting
Lazy loading
Image optimization
Caching
Virtualization
Backend performance
Latency
Throughput
Profiling
Database query optimization
Connection pooling
Backend caching
Async bottlenecks
Scalability
Horizontal scaling
Load balancing
Queues
Rate limiting
Backpressure
Measurement
Synthetic tests
Real user monitoring
Load testing
Benchmark pitfalls
Accessibility, SEO, and Internationalization
Accessibility
Semantic HTML
Keyboard navigation
Focus management
Color contrast
Screen readers
ARIA
WCAG basics
SEO
Metadata
Canonical URLs
Sitemap
Robots.txt
Structured data
SSR/SSG impact
Internationalization
Locale routing
Date/time formatting
Number formatting
Plurals
RTL basics
Product and engineering process
Requirements
Clarifying questions
Edge cases
Acceptance criteria
Delivery
Estimation
Trade-offs
Incremental delivery
Feature flags
Collaboration
Code review
Technical communication
Incident communication
Documentation
Interview communication
Thinking out loud
Explaining trade-offs
Asking about constraints
Defending decisions with evidence
Added beyond reference
AI-assisted development
LLM application integration
Privacy and data governance
Product analytics and experimentation
Payments and subscriptions
Offline-first synchronization
Mode
All modes
Quiz
Multi-choice
Flashcards
Output prediction
Count
Start session
Loading practice session...