Stacktrıck

Skip to content

Notes Topics Practice Problemsnew!Cheat sheets Roadmap

Practice now →

Notes→Topics→Practice→Problems→Cheat sheets→Roadmap→

Browse all interview resources

Choose a topic, read its explanations, then check your understanding with a quiz or coding exercise. This directory links directly to our public study pages.

Interview questions by topic

JavaScript questions and answers · MCQs
TypeScript questions and answers · MCQs
React questions and answers · MCQs
Angular questions and answers · MCQs
HTML & CSS questions and answers · MCQs
Node.js questions and answers · MCQs
Java questions and answers · MCQs
Spring Boot questions and answers · MCQs
Python questions and answers · MCQs
Microservices questions and answers · MCQs
SQL & PostgreSQL questions and answers · MCQs
MongoDB questions and answers · MCQs
Docker questions and answers · MCQs
Kubernetes questions and answers · MCQs
AWS questions and answers · MCQs
Git & CI/CD questions and answers · MCQs
ServiceNow questions and answers · MCQs
Data Structures & Algorithms questions and answers · MCQs
System Design questions and answers · MCQs
Networking questions and answers · MCQs
Operating Systems questions and answers · MCQs
Software Testing questions and answers · MCQs
Behavioral & HR questions and answers · MCQs
Next.js questions and answers · MCQs
Go questions and answers · MCQs
Apache Kafka questions and answers · MCQs
Redis questions and answers · MCQs
Machine Learning questions and answers · MCQs
Deep Learning questions and answers · MCQs
AI & LLM Engineering questions and answers · MCQs
MLOps questions and answers · MCQs
Statistics & Data Science questions and answers · MCQs

Articles and study guides

Containers vs Virtual Machines: Key Differences Explained
Script async vs defer vs type=module: Loading Order Explained
Abstract Class vs Interface in Java: When to Use Each
Checked vs Unchecked Exceptions in Java
HashMap vs ConcurrentHashMap in Java: Key Differences
String vs StringBuilder vs StringBuffer in Java
call vs apply vs bind in JavaScript: Differences With Examples
Callbacks vs Promises vs Async/Await in JavaScript Explained
localStorage vs sessionStorage vs Cookies: Key Differences
map vs forEach vs for...of in JavaScript: Which Loop to Use
Monolith vs Microservices: Trade-offs and the Modular Monolith
Redux vs Context API in React: Which One Should You Use?
@Component vs @Service vs @Repository in Spring
@Controller vs @RestController in Spring Boot
Spring vs Spring Boot: What Is the Difference?
DELETE vs TRUNCATE vs DROP in SQL (PostgreSQL)
INNER JOIN vs LEFT JOIN: Differences and the WHERE Trap
UNION vs UNION ALL in SQL: Duplicates and Performance
REST vs GraphQL: Differences, Trade-offs and When to Use Each
SQL vs NoSQL Databases: Differences and How to Choose
A/B Test Sample Size and the Peeking Problem: Interview Guide
Bayes' Theorem and the Base Rate Fallacy: Interview Guide
Central Limit Theorem Explained: Data Science Interview Guide
Confidence Intervals Explained: Data Science Interview Guide
Linear Regression Assumptions: What Breaks and How to Check
P-Values and Hypothesis Testing: Data Science Interview Guide
Simpson's Paradox and Correlation vs Causation: Interview Guide
T-Test vs Z-Test vs Chi-Square: Which Test to Use in Interviews
SGD, Momentum, Adam and AdamW: Optimizer Interview Guide
Backpropagation Explained: The Chain Rule, Step by Step
Batch Norm vs Layer Norm: Deep Learning Interview Question
CNN Interview Guide: Convolution, Pooling and Receptive Field
Dropout and Overfitting in Deep Neural Networks Explained
RNN vs LSTM vs GRU: How Gated Recurrent Networks Work
Self-Attention and Transformers Explained Step by Step
Vanishing and Exploding Gradients: Causes, Init and Fixes
Go Buffered vs Unbuffered Channels: Interview Guide
Go Context: Cancellation, Timeouts and Deadlines
Go Error Wrapping: %w, errors.Is and errors.As
Goroutines vs OS Threads: How the Go Scheduler Works
Go Data Races: Mutex, WaitGroup and the Race Detector
Go Interfaces and the Nil Error That Is Not Nil
Go Slices: len, cap, append and Shared Backing Arrays
Go Worker Pools and Goroutine Leaks Explained
Kafka Consumer Groups and Rebalancing Explained
Kafka Exactly-Once Semantics and Transactions Explained
Kafka Idempotent Producer, Batching and linger.ms
Kafka Offset Commits and Delivery Semantics Explained
Kafka Partitions, Offsets and Message Ordering Explained
Kafka Poison Messages, Retries and Dead Letter Topics
Kafka Replication, ISR and acks=all: Durability Explained
Kafka Retention vs Log Compaction: How Old Data Is Removed
Embeddings and Vector Search: AI Engineer Interview Guide
How to Evaluate LLM Applications: Evals and LLM Judges
Fine-Tuning vs RAG: When to Use Each in LLM Apps
LLM Function Calling and Agent Loops Explained
Prompt Injection Attacks and Defenses for LLM Apps
How to Design a RAG Pipeline: Chunking, Retrieval and Prompts
How to Reduce LLM Hallucinations in Production
LLM Tokens, Temperature and Top-p Sampling Explained
Bias-Variance Tradeoff Explained: ML Interview Guide
Cross-Validation and Data Leakage in Machine Learning
Gradient Descent Explained: Batch vs SGD vs Mini-Batch
Imbalanced Classification: Class Weights, SMOTE and PR-AUC
Logistic Regression Interview Questions: Sigmoid, Log Loss, Odds
Overfitting and L1 vs L2 Regularization Explained with Code
Precision vs Recall and F1 Score: ML Interview Guide
Random Forest vs Gradient Boosting: Bagging vs Boosting
Batch vs Online Inference: Choosing How to Serve a Model
CI/CD for Machine Learning: Pipelines and Continuous Training
Data Drift vs Concept Drift: Detecting Drift with PSI and KS
LLMOps: Prompt Versioning and Evaluation Gates in CI
MLflow Experiment Tracking and Model Registry Explained
Reproducible ML: Versioning Data, Code and Models
Shadow, Canary and A/B Deployments for ML Models
Training-Serving Skew and Feature Stores Explained
Next.js App Router vs Pages Router: Interview Guide
Next.js Caching and Revalidation: The Four Layers Explained
Fixing Next.js Hydration Errors: Causes and Solutions
Next.js Middleware: Auth Redirects, Matchers and Limits
Next.js Server Actions: Forms, Mutations and Security
Next.js Server vs Client Components: When to Use Each
Next.js SSR vs SSG vs ISR: Rendering Strategies Explained
Next.js Streaming with loading.tsx, Suspense and error.tsx
Redis Caching Patterns, Invalidation and Cache Stampedes
Redis Data Structures and When to Use Each One
Redis Distributed Locks: SET NX PX, Fencing and Redlock
Redis Eviction Policies and Key Expiry: LRU, LFU and TTL
Redis Persistence: RDB vs AOF and fsync Trade-offs
Redis Rate Limiting with Lua: Fixed Window to Token Bucket
Redis Replication, Sentinel and Cluster Hash Slots
Why Is Redis Single-Threaded? Event Loop and I/O Threads
Angular Defer Blocks and Lazy Rendering
Angular Global Error Handling
Angular Host Directives and Composition
Angular Pure and Impure Pipes
Angular Resource API for Async Data
Angular Signal Forms Overview
Angular SSR and Hydration Consistency
Angular Template-Driven vs Reactive Forms
Angular Zoneless Change Detection
Bit Manipulation Patterns for Interviews
Java Generics Wildcards and PECS
JavaScript Array Methods: Mutating Versus Returning New
JavaScript Date and Timezone Pitfalls
JavaScript Number Precision and BigInt
JavaScript Object Destructuring and Defaults
JavaScript Optional Chaining and Nullish Coalescing
JavaScript Timeouts with Promise.race
JavaScript RegExp Stateful Flags and lastIndex
JavaScript Rest and Spread Gotchas
JavaScript Symbols and Well-Known Symbols
MongoDB Bulk Writes
MongoDB Capped Collections
MongoDB Change Streams and Resume Tokens
MongoDB Collation and Case-Insensitive Queries
MongoDB GridFS for Large Files
Networking: DNS Caching and TTL
Networking: DNS Record Types
Networking: HTTP Redirects
HTTP/3 and QUIC Transport
Networking: IP Subnetting and CIDR
Networking: L4 vs L7 Load Balancing
Networking: MTU and Fragmentation
Networking: TCP Flow Control
Networking: The TLS Handshake
Node.js Caching Layers and Invalidation
Node.js Clustering Across CPU Cores
Node.js Password Hashing with scrypt
Node.js ESM and CommonJS Interop
Node.js HTTP Security Headers
Node.js Retries with Backoff and Jitter
Node.js Structured Logging
Node.js URL and URLSearchParams
Node.js Response Compression with zlib
Operating Systems: CPU Cache Locality
Copy-on-Write Memory and fork
Operating Systems: epoll and select
Operating Systems: I/O Models
Operating Systems: Journaling and Durability
Python asyncio.gather and Timeouts
React Live Regions and Screen Reader Announcements
React Context Splitting for Performance
React lazy Loading and Code Splitting
React Portals and Event Bubbling
React Server Components and 'use client': What Crosses the Line
React StrictMode and Double-Invoked Effects
React Form Actions with useActionState
React useOptimistic and Instant Feedback
React Imperative Handles with useImperativeHandle
ServiceNow ACL Scripting and Access
ServiceNow Caching and Invalidation
ServiceNow Dictionary and Field Audit
ServiceNow g_form and Client Script Design
ServiceNow Notification Controls
ServiceNow Record Producers
ServiceNow REST API Design
ServiceNow Scheduled Jobs
ServiceNow Update Sets and Conflicts
Spring @Async and Executor Configuration
Spring Boot Caching Abstraction
Spring Declarative HTTP Clients
Spring Boot Problem Details for APIs
Spring Boot REST Pagination
Spring Boot Scheduled Tasks
Spring Boot Testcontainers
Spring Boot Distributed Tracing
Spring Bean Validation Groups
PostgreSQL CASE Expressions
PostgreSQL Date Truncation and Ranges
PostgreSQL Deadlocks and Retry
PostgreSQL Generated Columns
SQL WHERE vs HAVING
PostgreSQL JSONB Columns and Indexing
PostgreSQL Recursive CTEs for Hierarchies
PostgreSQL Self-Joins
PostgreSQL Set Operations
System Design: Backpressure and Load Shedding
System Design: Bloom Filters
System Design: Idempotent APIs
System Design: Leader Election and Fencing
System Design: Notification System
System Design: Presence Tracking
System Design: Schema Evolution
System Design: Time-Series Metrics
System Design: URL Shortener
Testing Time with an Injected Clock
Code Coverage and Its Limits
Scoping End-to-End Tests
Testing Error Paths
Unit and Integration Test Balance
Parallel Test Isolation
Red, Green, Refactor
Snapshot Tests Worth Reviewing
Test Data Builders and Object Mothers
TypeScript Abstract Classes: What They Enforce and When
TypeScript Declaration Files and Untyped Packages
TypeScript Enums vs Union Types
TypeScript Generic Defaults and Parameter Order
TypeScript Index Signatures and Constraints
TypeScript Key Remapping in Mapped Types
TypeScript Strict Compiler Flags
TypeScript Template Literal Types
TypeScript this Types and Fluent APIs
Can't bind to 'ngModel' since it isn't a known property of 'input' in Angular
Angular 'Blocked by CORS Policy' on ng serve: Fix with proxy.conf.json
ExpressionChangedAfterItHasBeenCheckedError in Angular (NG0100)
'app-x' is not a known element in Angular (NG8001): How to Fix It
NullInjectorError: No provider for X! in Angular (NG0201): How to Fix
Docker Container Exits Immediately: How to Debug It
Docker 'exec format error': When the Image CPU Does Not Match
Docker 'no space left on device': Safe Cleanup for Builds and Pulls
Docker permission denied on /var/run/docker.sock: Fixes and Risks
Docker 'Bind for 0.0.0.0:8080 failed: port is already allocated' Fix
Git: Your branch and 'origin/main' have diverged (Fix)
Git: failed to push some refs (fetch first, non-fast-forward)
Git Permission denied (publickey) on GitHub: SSH Fix
Git fatal: refusing to merge unrelated histories (How to Fix)
How to Undo the Last Commit in Git: reset, amend, revert
ClassNotFoundException vs NoClassDefFoundError in Java
Java ConcurrentModificationException: Removing Items Safely
Java NullPointerException: Reading the Message and Fixing the Cause
java.lang.OutOfMemoryError: Java Heap Space: Diagnosis and Fixes
UnsupportedClassVersionError: Class File Version Mismatch in Java
UnsupportedOperationException from Arrays.asList and List.of
JavaScript Array Sort Comparators
JavaScript Async Iteration and Backpressure
Fixing 'Blocked by CORS Policy' Errors in JavaScript fetch
TypeError: Cannot Read Properties of Undefined in JavaScript
Cannot Use Import Statement Outside a Module: ESM vs CommonJS
JavaScript Custom Error Classes
TypeError: x Is Not a Function in JavaScript: Causes and Fixes
RangeError: Maximum Call Stack Size Exceeded in JavaScript
JavaScript Proxy Traps for Validation
ReferenceError: x Is Not Defined vs undefined in JavaScript
JavaScript structuredClone and Transferables
SyntaxError: Unexpected Token '<' in JSON: Debugging fetch
Uncaught (in promise): Fixing Unhandled Promise Rejections
Kubernetes CrashLoopBackOff: Back-off restarting failed container
Kubernetes CreateContainerConfigError: Missing Config or Secret
Kubernetes ImagePullBackOff: ErrImagePull, Failed to pull image
Kubernetes OOMKilled and Exit Code 137: Fix Memory Limits
Kubernetes Pod Stuck in Pending: '0/3 nodes are available' Fixed
Error: Cannot find module in Node.js (MODULE_NOT_FOUND)
Error: listen EADDRINUSE: address already in use in Node.js
Error: connect ECONNREFUSED 127.0.0.1 in Node.js (and ::1)
Node.js 'JavaScript heap out of memory': Reached Heap Limit Fix
npm error code EACCES: Permission Denied on npm install -g
npm error code ERESOLVE: Unable to Resolve Dependency Tree
pip error: externally-managed-environment in Python (PEP 668)
IndentationError: expected an indented block in Python
KeyError in Python: Fix Missing Dictionary Keys Safely
ModuleNotFoundError: No module named 'x' in Python
TypeError: 'NoneType' object is not subscriptable in Python
UnboundLocalError: cannot access local variable in Python
React: Cannot Update a Component While Rendering a Different One
React Invalid Hook Call: Hooks Can Only Be Called Inside a Component
Maximum Update Depth Exceeded in React: Causes and Fixes
Objects Are Not Valid as a React Child: Causes and Fixes in React
React State Not Updating Immediately After setState: How to Fix
Too Many Re-renders. React Limits the Number of Renders: How to Fix
Spring @Autowired Field Is Null: Why Injection Didn't Happen
Spring Boot Circular Dependency: 'Beans Form a Cycle' Fix
Configuring CORS in Spring Boot: Fixing 'Blocked by CORS Policy'
Spring Boot: Failed to Configure a DataSource ('url' Not Specified)
Jackson Infinite Recursion with JPA Entities in Spring Boot
Spring Boot: No Qualifying Bean of Type (Could Not Be Found)
Web Server Failed to Start: Port 8080 Was Already in Use
Whitelabel Error Page 404 in Spring Boot: How to Fix It
Duplicate Key Value Violates Unique Constraint in PostgreSQL
Column Must Appear in the GROUP BY Clause in PostgreSQL
PostgreSQL 'operator does not exist': Fixing Type Mismatches
PostgreSQL 'relation does not exist': Cause and Fix
PostgreSQL 'sorry, too many clients already': Cause and Fix
TypeScript TS2345: Not Assignable to Parameter of Type 'never'
TS2307: Cannot Find Module or Its Type Declarations in TypeScript
TypeScript Const Type Parameters
TypeScript Declaration Merging and Module Augmentation
TS7053: Element Implicitly Has an 'any' Type in TypeScript
TypeScript Excess Property Checks
TypeScript Function Overloads and Resolution
TS2532: Object Is Possibly 'undefined' (and TS18048) in TypeScript
TS2339: Property 'x' Does Not Exist on Type 'Y' in TypeScript
TS2322: Type 'X' Is Not Assignable to Type 'Y' in TypeScript
TypeScript Type Predicates and Assertion Functions
Angular HTTP Request Contract Tests
JavaScript Single-Flight Requests
Node.js Events and Listener Ordering
Python Bounded Async Worker Queues
React Deferred Results and Stale UI
PostgreSQL Concurrent Job Claiming
Angular Async Validators and Pending State
Angular Component Tests That Verify Behavior
Angular Content Projection with ng-content and ng-template
Angular Custom Controls and Value Accessors
Angular providedIn root vs Component Providers vs viewProviders
Angular HTTP Error Handling: catchError and Safe Retries
Angular HTTP Interceptors and Request Immutability
Angular Inject and Injection Contexts
Angular Lazy Loading Routes: Why Your Lazy Feature Isn't Lazy
Angular OnPush and Input Reference Changes
Angular Reactive Forms: patchValue vs setValue and Lost Edits
Angular Cross-Field Validation with Reactive Forms
Angular Route Guards and Server Authorization
Angular Route Parameters and Reused Components
Angular Resolvers and Navigation Data
Choosing an RxJS Mapping Operator in Angular: Search, Save, Login
Angular Computed Signals and Derived Values
Angular Effects and External Synchronization
Angular Signals and Immutable Collection Updates
Angular Standalone Components and Template Imports
Angular Unsubscribe: Which Subscriptions Leak and How to Clean Up
Angular View Queries and Lifecycle Timing
API Gateway and Lambda Errors: One Error Format for Clients
AWS Auto Scaling and Dependency Limits
AWS CloudWatch Metrics, Logs and Alarm Meaning
AWS Cost Visibility and Bounded Experiments
AWS DynamoDB Keys and Access Patterns
AWS DynamoDB Conditional Writes and Concurrency
AWS IAM Policies and Permission Decisions
AWS Lambda Execution Environment: Init, Reuse and Timeouts
AWS Lambda Retries and Idempotent Handlers
AWS NAT Gateways and Private Outbound Access
AWS RDS Connections and Database Capacity
AWS Roles and Temporary Credentials
Amazon S3 Consistency, Overwrites and Access Control Explained
AWS S3 Versioning and Recovery Limits
AWS Security Groups Versus Network ACLs
AWS Shared Responsibility Model: What You Secure vs AWS
AWS SNS Fanout and Subscriber Independence
AWS SQS Delivery and Visibility Timeouts
AWS VPC Routes and Network Reachability
AWS Architecture Trade-Offs: Availability, RTO, RPO and DR Costs
Behavioral Interviews: Working With Ambiguous Requirements
Behavioral Interviews: Explaining a Career Transition
Behavioral Interviews: Resolving Technical Disagreement
Behavioral Interviews: Customer Impact and Evidence
Behavioral Interviews: Handling an Unrealistic Deadline
Behavioral Interviews: Responding to Uncomfortable Pressure
Behavioral Interviews: Failure and Specific Learning
Behavioral Interviews: Receiving Difficult Feedback
Behavioral Interviews: Communicating During an Incident
Behavioral Interviews: Leading Without Formal Authority
Behavioral Interviews: Mentoring and Knowledge Transfer
Reviewing a Mock Behavioral Interview
Behavioral Interviews: Prioritizing Competing Work
Explaining Project Ownership in an Interview
Behavioral Interviews: Balancing Quality and Delivery
Questions to Ask About a Role and Team
Interview Introductions With Relevant Evidence
Behavioral Interviews: Explaining Technical Trade-Offs
Behavioral Interviews: A Clear STAR Story
Behavioral Interviews: A Useful Weakness Answer
Docker Multi-Platform Images and Native Dependencies
Docker Bind Mounts and Host Coupling
Docker Compose Dependencies and Readiness
Docker Entrypoint and Command Overrides
Docker Health Checks and Useful Probes
Docker Build Context and Ignore Rules
Docker Images Versus Running Containers
Docker Base Image Maintenance and Dependency Updates
Docker Image Tags and Reproducible Releases
Docker Layers and Build Cache Invalidation
Docker Logs and Application Diagnostics
Docker Multi-Stage Builds and Runtime Contents
Docker Networks and Container DNS
Docker Nonroot Users and File Permissions
Docker Exposed Ports Versus Published Ports
Docker Read-Only Filesystems and Writable Paths
Docker Resource Limits and Application Capacity
Docker Secrets and Image Layer History
Docker Process Signals and Graceful Shutdown
Docker Volumes: When Container Data Survives or Gets Deleted
Backtracking and Safe Pruning Rules
Big-O Complexity and Input Growth
Binary Search on an Answer Space
Binary Search Without Off-by-One Bugs: The Invariant Method
Dynamic Programming and State Definition
Graph DFS States and Cycle Detection
Hash Maps for Frequency and Membership Problems
Heaps for Top-K and Incremental Selection
Linked List Cycles and Fast-Slow Pointers
Reverse a Linked List: Iterative, Recursive and Sublist Versions
Monotonic Stacks and Nearest Greater Elements
Prefix Sums for Repeated Range Queries
Breadth-First Search and Unweighted Shortest Paths
Sliding Window Technique for Subarray and Substring Problems
Algorithm Space Complexity and Auxiliary Storage
Stacks for Balanced Delimiters and Nested Structure
Topological Sorting and Dependency Order
Tree Traversals and Information Flow
Two Pointers and Monotonic Search Decisions
Union-Find for Connectivity and Components
Git Bisect and Reproducible Regression Checks
Git Branching Strategies and Integration Frequency
CI Build Once and Promote the Same Artifact
CI Canary Releases and Decision Metrics
Git Cherry-Pick and Patch-Based Backports
CI Required Checks and Meaningful Validation
Git Atomic Commits and Reviewable Changes
How to Resolve Git Merge Conflicts Correctly (with zdiff3)
Feature Flags in CI/CD: Percentage Rollouts and Flag Cleanup
Git Ignore Rules and Already Tracked Files
CI Merge Queues and Combined Change Validation
Git Merge Versus Rebase and Shared History
CI Caches Versus Reproducible Build Inputs
Git Reflog and Recovering Lost References
CI Release Versions and Artifact Traceability
Git Revert Versus Reset for Undoing Changes
CI Rollbacks and Data Compatibility
CI Secrets and Untrusted Contributions
Git Stash Explained: What It Saves, Pop Conflicts and Alternatives
Git Working Tree, Index and Commit Snapshots
HTML Data Tables and Header Relationships
HTML Buttons Versus Links for Actions
CSS Container Queries for Reusable Components
CSS Box Sizing and Predictable Dimensions
CSS Custom Properties (Variables): Inheritance, var() and Theming
CSS Flex Items and Unexpected Overflow
CSS Focus Visibility and Keyboard Navigation
HTML Form Labels and Accessible Names
CSS Grid Tracks and Minmax Sizing
HTML Headings and Document Navigation
HTML Alt Text Based on Image Purpose
HTML Image Loading and Page Priorities
CSS Logical Properties for Direction-Aware Layout
CSS Positioning and Containing Blocks
HTML Progressive Enhancement and Reliable Navigation
CSS Reduced Motion and Meaningful Alternatives
HTML Responsive Images and Source Selection
CSS Responsive Units and Content Constraints
HTML Landmarks and Meaningful Page Structure
CSS Z-Index and Stacking Contexts
Java ArrayList Capacity and Performance
Java Comparators and Ordered Collections
Java CompletableFuture Error Composition
Java Concurrent Collections and Compound Operations
Java equals() and hashCode(): The Rules and HashMap Bugs
Java Exception Handling: Where to Catch, Wrap and Rethrow
Java Executors and Task Lifecycle
Java Garbage Collection and Retained Objects
Java HashMap Collisions and Key Quality
Java Immutable Objects and Defensive Copies
Java Time Types and Zone-Aware Decisions
Java Optional: When to Use It and Common Mistakes
Java Records and Shallow Immutability
Java Streams and Lazy Pipelines
Java 'stream has already been operated upon or closed' Explained
Java String equals() vs ==: Why == Fails and How to Compare
Java synchronized Explained: Locks, Visibility and Reentrancy
Java Thread Visibility and Happens-Before
Java Try-With-Resources and Cleanup
Java Virtual Threads and Blocking Workloads
AbortController in JavaScript: Cancel fetch and Stale Requests
JavaScript Array Copies and Shared Objects
JavaScript reduce(): Initial Value, Accumulator and Mutation
Async/Await in Loops: forEach vs for...of vs Promise.all
JavaScript == vs ===: Type Coercion and Object Comparison
JavaScript Event Delegation and Dynamic Elements
JavaScript Object.freeze: Shallow vs Deep Freeze and Limits
JavaScript Generators: return(), finally and Cleanup on Early Exit
JavaScript Iterator Protocol: Make Any Object Iterable
JavaScript Map vs Object: When to Use Each (Interview Answer)
JavaScript Memory Leaks and Retained References
ES Module Live Bindings vs CommonJS: Interview Guide
Nullish Coalescing (??) vs OR (||) in JavaScript: Defaults Explained
Promise.all vs allSettled vs race vs any: JavaScript Interview Guide
Promise finally() in JavaScript: Cleanup Without Losing Errors
JavaScript Property Descriptors: writable, enumerable, configurable
for...in vs Object.keys vs Reflect.ownKeys: Key Order Explained
Prototype Pollution in JavaScript: How It Works, How to Prevent It
Remove Duplicates from a JavaScript Array with Set (and Objects)
WeakMap vs Map in JavaScript: Garbage Collection and Leaks
Kubernetes Autoscaling and Meaningful Metrics
Kubernetes ConfigMaps Versus Secrets
Kubernetes CronJobs and Overlapping Runs
Kubernetes Deployments and Rolling Updates
Kubernetes Ingress Explained: Controllers, Host Rules, 404 vs 503
Kubernetes Jobs and Repeatable Batch Work
Kubernetes Namespaces and Isolation Limits
Kubernetes Network Policies and Traffic Direction
Kubernetes Node Affinity vs Taints and Tolerations vs nodeSelector
Kubernetes Persistent Volumes and Claims
Kubernetes Disruption Budgets and Maintenance
Kubernetes Pods and Disposable Workload Instances
Kubernetes Startup, Readiness and Liveness Probes
Kubernetes RBAC and Least-Privilege Access
Kubernetes Requests, Limits and Scheduling
Kubernetes Security Contexts and Runtime Permissions
Kubernetes Service Selectors and Endpoints
Kubernetes StatefulSet vs Deployment: Stable Names and Storage
Kubernetes Pod Termination and Connection Draining
Kubernetes Troubleshooting From Symptoms to Evidence
Microservice API Gateways and Edge Responsibilities
Microservice Bulkheads and Resource Partitioning
Microservice Circuit Breakers and Failure Isolation
Microservice Configuration and Safe Rollouts
Microservice Consumers and Duplicate Events
Evolving Microservice APIs and Events Without Breaking Consumers
Database per Service: Why Microservices Shouldn't Share Tables
Microservice Deadlines Across Call Chains
Microservice Tracing and Request Causality
Microservice Event Ordering and Partition Keys
Microservice Idempotency Keys and Repeated Requests
Migrating a Monolith to Microservices One Capability at a Time
Microservices Transactional Outbox and Event Delivery
Microservice Read Models and Eventual Consistency
Microservice Failure Tests and Recovery Evidence
Microservice Retry Budgets and Amplification
Microservice Sagas and Compensation Limits
How to Define Microservice Boundaries Around Business Capabilities
Microservice Discovery and Changing Endpoints
Microservices: Synchronous Calls Versus Messaging
MongoDB Aggregation Pipeline Stage Order
MongoDB ObjectId Explained: What's Inside and Custom _id
MongoDB Compound Indexes and Query Order
MongoDB Single-Document Atomicity and Updates
MongoDB Embedding Versus Referencing
MongoDB Explain Plans and Examined Documents
MongoDB Lookup and Relationship Cost
MongoDB Missing Fields Versus Null
MongoDB Multikey Indexes for Array Fields
MongoDB Cursor Pagination and Stable Ordering
MongoDB Partial Indexes and Subset Queries
MongoDB Read Concern and Consistency Expectations
MongoDB Replica Sets and Primary Elections
MongoDB Schema Validation and Flexible Records
MongoDB Shard Keys and Workload Distribution
MongoDB Transactions and Data Modeling
MongoDB TTL Indexes and Eventual Expiration
MongoDB Unique Indexes and Domain Constraints
MongoDB Unwind and Expanded Results
MongoDB Write Concern and Acknowledgement
HTTP Connection Reuse and Latency
CORS and Browser Response Access
DNS Resolution and Cached Answers
HTTP ETags and Conditional Requests
HTTP Cache-Control and Response Freshness
HTTP Cookies, Scope and Browser Delivery
HTTP Methods, Safety and Idempotence
HTTP Status Codes and Client Decisions
HTTP/2 Multiplexing and Head-of-Line Blocking, vs HTTP/3
Network Latency Versus Bandwidth
Network Debugging Along the Request Path
HTTP Preflight Requests and Allowed Operations
Reverse Proxies and Trusted Forwarded Headers
TCP Byte Streams and Message Framing
Server-Sent Events and One-Way Updates
TCP Connections and the Handshake
Network Timeouts and Operation Deadlines
TLS Certificate Validation: Why the Hostname Check Matters
UDP Delivery and Application Responsibilities
WebSocket Lifecycle: Handshake, Heartbeats and Close Codes
Node.js AsyncLocalStorage for Request Context
Node.js Blocking Work and Request Latency
Node.js Request Body Validation and Limits
Node.js Buffers and UTF-8: Fixing Corrupted Text Across Chunks
Node.js Child Processes and Argument Safety
Node.js Database Pools and Concurrency
Node.js Async Error Handling: Floating Promises and try/catch Gaps
Node.js File Paths and Traversal Prevention
Node.js Graceful Shutdown and In-Flight Requests
Node.js Health Checks and Service Readiness
Node.js HTTP Timeouts and Resource Limits
How Node.js Resolves Modules: ESM, CommonJS and Extensions
Node.js Package Exports and Public APIs
Node.js Latency Measurement and Event Loop Delay
Node.js stream.pipeline() vs .pipe(): Handling Stream Errors
Node.js Environment Variables and Configuration
Node.js Streams and Backpressure
Node.js Test Isolation and Async Completion
Node.js Timers and Scheduling Guarantees
Node.js Worker Threads and CPU Parallelism
Condition Variables and Predicate-Based Waiting
Context Switching and Scheduling Overhead
CPU Scheduling and Response-Time Goals
Deadlock Conditions and Lock Ordering
File Descriptors and Resource Exhaustion
Filesystem Writes, Buffers and Durability
Interrupts and Device Completion Notifications
IPC Compared: Pipes vs Unix Sockets vs TCP vs Shared Memory
Mutex vs Semaphore: The Difference, With Real Examples
Operating-System Page Cache and I/O Measurements
Paging, Page Faults and Memory Access
Priority Inversion Explained: Priority Inheritance and Mars Pathfinder
Processes Versus Threads and Shared State
Producer-Consumer Queues and Backpressure
Race Conditions and Atomic State Transitions
Stack vs Heap Memory: Allocation, Lifetimes and Stack Overflow
Starvation and Fairness in Locks and CPU Scheduling
User Mode, Kernel Mode and Privileged Operations
Virtual Memory and Address-Space Isolation
Working Sets and Memory Thrashing
Python Asyncio and Blocking Functions
Python Asyncio Tasks and Cancellation
Python Closures and Late Binding
Python Comprehensions and Readable Transformations
Python Context Managers and the with Statement Explained
Python Shallow Copies and Nested Mutability
Python Dataclasses and Mutable Fields
Python Decorators and Function Metadata
Python Exception Chaining and Diagnostic Context
Python Generators and Single-Pass Iteration
Python Hashability and Dictionary Keys
Python is vs ==: Identity, Equality and When to Use Each
Python Imports and Side Effects
Python Iterators and Exhaustion
Python Mutable Defaults and Shared State
Python Pathlib and Safe File Selection
Python Stable Sorting and Key Functions
Python Test Fixtures and State Isolation
Python Threads, Processes and Workload Choice
Python Virtual Environments and Reproducible Dependencies
React Dialogs: Focus, Escape and Restoration
React UseCallback and Captured Values
React Context Scope and Update Costs
Controlled vs Uncontrolled Inputs in React
React Custom Hooks and Shared Logic
React Derived Values Without Extra State
React useEffect Cleanup: When It Runs and How to Avoid Leaks
React Effect Dependencies and Synchronization
React Error Boundaries and Recovery Scope
React External Stores and Consistent Snapshots
React Fetch Race Conditions: Cleanup and AbortController
React Hydration and Matching Initial Content
React Layout Effects for DOM Measurement
React List Keys: Why Index Keys Break State
React Memo and Reference Stability
React Reducers and Valid State Transitions
React Refs Versus State for Mutable Values
React Resetting Forms With Component Keys
React State Snapshots and Event Handlers
Where to Put React Suspense Boundaries and Avoid Waterfalls
React Transitions and Urgent Input Updates
React Functional Updates and Pure State Changes
ServiceNow ACLs and Record Access Decisions
ServiceNow Approvals and Decision Traceability
ServiceNow Automated Test Framework and Release Evidence
ServiceNow Business Rule Timing and Side Effects
ServiceNow Client Scripts Versus Server Enforcement
ServiceNow CMDB Identification and Data Quality
ServiceNow Flow Designer: Triggers, Run Options, Duplicates
ServiceNow GlideAggregate for Summary Queries
ServiceNow GlideAjax and Asynchronous Client Calls
ServiceNow GlideRecord Queries and Bounded Results
ServiceNow Import Sets and Transform Maps
ServiceNow Incident, Problem and Change Roles
ServiceNow Integrations and Retry-Safe Operations
ServiceNow Reference Fields: sys_id vs Display Value Explained
ServiceNow Business Rule Conditions and Scope
ServiceNow Scoped Applications and Cross-Scope Access
ServiceNow Script Includes and Reusable Server Logic
ServiceNow Table Inheritance and Shared Behavior
ServiceNow UI Policies and Form Behavior
ServiceNow Update Sets and Deployment Scope
Spring Actuator Exposure and Operational Access
Spring Boot Auto-Configuration and Explicit Overrides
Spring Bean Scopes and Shared Mutable State
Spring Configuration Properties and Validation
Spring Constructor Injection and Required Dependencies
Spring CSRF Protection and Authentication Transport
Spring Controller Advice and Error Responses
Spring Boot RestClient and WebClient Timeouts: How to Set Them
LazyInitializationException in Spring Boot JPA: Causes and Fixes
Spring JPA N-Plus-One Query Diagnosis
Spring Metrics Tags and Cardinality
Spring JPA Optimistic Locking and Conflicts
Spring Profiles and Environment Differences
@DataJpaTest vs Testcontainers: Testing Spring Data Repositories
Spring Boot Request Validation with @Valid: Clear 400 Errors
Spring Transaction Rollback Rules and Exceptions
Spring Security SecurityFilterChain: Multiple Chains and @Order
Spring Startup Checks and Readiness
Spring Transaction Duration and Remote Calls
Spring Transactions and Proxy Invocation
SQL Aggregation and Result Grain
PostgreSQL Composite Indexes and Query Patterns
SQL Constraints as Concurrent Safety Nets
SQL Count Star Versus Count Column
SQL Common Table Expressions and Query Structure
SQL Exists for Relationship Checks
PostgreSQL Explain Analyze and Real Execution
SQL Joins and Unexpected Row Multiplication
SQL Keyset Pagination and Stable Ordering
SQL Left Joins and Filter Placement
PostgreSQL MVCC, Old Versions and Vacuum
SQL Normalization and Deliberate Denormalization
SQL Null and Three-Valued Logic
PostgreSQL Partial Indexes for Focused Workloads
SQL Parameterization and Injection Prevention
SQL Row Number, Rank and Dense Rank
PostgreSQL Row Locks and Concurrent Updates
SQL Transaction Isolation and Observable Anomalies
PostgreSQL Upsert with INSERT ON CONFLICT: A Practical Guide
SQL Window Functions Without Collapsing Rows
Designing Long-Running APIs: 202 Accepted and Idempotency Keys
System Design Cache-Aside and Stale Data
System Design Cache Stampedes and Refill Coordination
System Design Capacity Estimates and Assumptions
System Design CDNs and Cacheable Content
System Design Consistency and User Expectations
System Design Graceful Degradation and Correctness
System Design Reviews Through Concrete Failure Cases
News Feed System Design: Fan-Out on Write vs Fan-Out on Read
System Design IDs and Ordering Requirements
System Design Load Balancing and Healthy Capacity
System Design Multi-Region Recovery and Data Risk
System Design Observability and Failure Questions
System Design Partitioning and Hot Keys
System Design Queues and Backlog Management
System Design Rate Limiting and Fairness
System Design Replication and Read Freshness
System Design Requirements Before Components
Keeping a Search Index in Sync With Your Database
System Design Uploads and Safe Completion
Accessibility Tests Beyond Automated Scans
Arrange, Act and Assert for Clear Tests
Async Tests and Controlled Completion Order
Testing Observable Behavior Instead of Implementation
Boundary-Value Tests and Off-By-One Errors
Contract Testing Across Independent Services
Database Tests and Representative Engine Behavior
Equivalence Partitions for Efficient Test Coverage
Fake Timers and Clock-Based Behavior
Test Fixtures and Independent State
Flaky Tests and Root-Cause Evidence
Mocks, Stubs and Fakes: Dependency Test Choices
Mutation Testing and Assertion Strength
Performance Tests and Realistic Workloads
Property-Based Testing in JavaScript with fast-check
Regression Tests and Change Risk
Security Tests for Rejected Operations
Unit vs Integration vs End-to-End Tests: What Each Should Cover
Test Reports and Honest Coverage Claims
Visual Regression Tests and Stable Comparisons
TypeScript Branded IDs and Domain Safety
How to Test TypeScript Types: @ts-expect-error and Type Equality
TypeScript Conditional Types and Distribution
TypeScript Discriminated Unions for UI State
TypeScript Error Handling Without Unsafe Casts
TypeScript Function Variance in Callbacks
TypeScript Generic Constraints and Relationships
TypeScript Infer for Type Extraction
TypeScript Keyof and Safe Property Access
TypeScript Literal Inference and Const Assertions
TypeScript Mapped Types and Modifiers
TypeScript Type Imports and Runtime Modules
TypeScript Never and Exhaustive Checks
TypeScript Optional Properties and Presence
TypeScript readonly Arrays, ReadonlyMap and ReadonlySet
TypeScript Satisfies Without Losing Inference
TypeScript Null Narrowing Across Control Flow
TypeScript Structural Typing and Excess Properties
TypeScript Tuples for Fixed Position Data
TypeScript unknown vs any: Validating JSON and API Responses
Frontend System Design: Build an Autocomplete
Closures, Scope & the Classic setTimeout Loop
TypeScript Generics, Explained Through Interview Questions
The Event Loop: Microtasks vs Macrotasks
useEffect Pitfalls Interviewers Love to Ask
The this Keyword: Four Binding Rules and One Exception
Angular Change Detection, OnPush & Signals Demystified
Hoisting, the TDZ and var vs let vs const
type vs interface: When It Actually Matters
React Reconciliation & Keys: What Really Happens
Prototypes & Inheritance Without the Headache
switchMap vs mergeMap vs concatMap vs exhaustMap
Implement Debounce and Throttle From Scratch
Build TypeScript's Utility Types From Scratch
memo, useMemo and useCallback: When They Actually Help
Angular Dependency Injection: Providers, Scopes & inject()
The Node.js Event Loop Phases, Explained
The Cascade, Specificity & the Box Model
Write Promise.all (and Friends) From Scratch

Cheat sheets

Practice tools

Practice room and interview checklist
Multiple-choice quizzes
Flashcards
Mock interviews
Speed rounds
Frontend study roadmap

Coding challenges

Chunk an array
Flatten a nested array
Implement groupBy
Implement compose and pipe
Implement memoize
Implement get(obj, path)
Implement curry
Implement debounce
Implement throttle
Build an event emitter
Implement deepClone
Implement Promise.all
Design an LRU cache
Run promises with a concurrency limit

Algorithm problems

About the site

About Stacktrick
About the author
Editorial approach
Privacy policy
Subscribe to the article feed

Free developer interview prep: JavaScript, React, Java, Python, SQL, AWS and Kubernetes questions with model answers, quizzes and mock interviews.

Chapters

Frontend: JavaScript TypeScript React Angular HTML & CSS Next.js
Backend: Node.js Java Spring Boot Python Microservices Go Apache Kafka
Databases: SQL & PostgreSQL MongoDB Redis
Cloud & DevOps: Docker Kubernetes AWS Git & CI/CD
Platforms: ServiceNow
Fundamentals: Data Structures & Algorithms System Design Networking Operating Systems Software Testing Behavioral & HR
AI & Machine Learning: Machine Learning Deep Learning AI & LLM Engineering MLOps Statistics & Data Science

Practice

Problems
Quiz
Flashcards
Mock interview
Voice coach
Speed round
Coding round
Your progress

More

All notes
Error fixes
AI & ML path
Cheat sheets
Roadmap
About
Contact
Editorial approach
Browse all resources
RSS feed
Privacy policy

© 2026 Stacktrick · by Aditya Mishramade with ☕ and way too many console.logsProgress is saved in your browser only.

esc

↑ ↓ to move↵ to openesc to close