A/B Test Sample Size and the Peeking Problem: Interview Guide
Size an A/B test from baseline, MDE, alpha and power, turn it into days, and see by simulation why stopping at the first p below 0.05 fails.
~8 min readread →
Notes by Aditya
All notes →Bayes' Theorem and the Base Rate Fallacy: Interview Guide
Solve the classic 1% disease test question three ways, see why rare events wreck precision, and avoid the base rate traps interviewers set.
~8 min readread →
Central Limit Theorem Explained: Data Science Interview Guide
What the central limit theorem really promises, shown by simulation on skewed revenue data, and where it quietly breaks in A/B tests.
~9 min readread →
Confidence Intervals Explained: Data Science Interview Guide
What 95% confidence really means, how to build t, Wilson and bootstrap intervals in Python, and why the textbook proportion interval fails.
~8 min readread →
Linear Regression Assumptions: What Breaks and How to Check
The OLS assumptions interviewers expect, which violations bias coefficients and which only break standard errors, with Python checks for each.
~10 min readread →
P-Values and Hypothesis Testing: Data Science Interview Guide
What a p-value actually measures, how to run a two-proportion test by hand in Python, and the misreadings that sink data science candidates.
~8 min readread →
Simpson's Paradox and Correlation vs Causation: Interview Guide
Why a variant can win in every segment yet lose overall, how to standardise for mix, and how to tell confounders from causes in product data.
~8 min readread →
T-Test vs Z-Test vs Chi-Square: Which Test to Use in Interviews
Pick the right test from the data type and design: two-proportion z-tests, Welch and paired t-tests, and chi-square, each run in Python.
~9 min readread →
SGD, Momentum, Adam and AdamW: Optimizer Interview Guide
How SGD, momentum, Adam and AdamW update weights, why AdamW decouples weight decay, and how warmup and cosine decay keep training stable.
~9 min readread →
Backpropagation Explained: The Chain Rule, Step by Step
How backpropagation applies the chain rule layer by layer, worked by hand on a tiny network with softmax cross-entropy and a gradient check.
~9 min readread →
Batch Norm vs Layer Norm: Deep Learning Interview Question
How batch norm and layer norm compute their statistics, why model.eval() matters, why small batches hurt, and why transformers use LayerNorm.
~9 min readread →
CNN Interview Guide: Convolution, Pooling and Receptive Field
How a conv layer slides a kernel, the output size and parameter formulas, pooling, and how receptive field grows, with runnable Python.
~10 min readread →
Dropout and Overfitting in Deep Neural Networks Explained
How to spot overfitting in loss curves, why inverted dropout scales by 1/(1-p), and how weight decay, augmentation and early stopping help.
~9 min readread →
RNN vs LSTM vs GRU: How Gated Recurrent Networks Work
How RNNs, LSTMs and GRUs process sequences, why gradients vanish through time, how gates fix it, and how to count each model's parameters.
~9 min readread →
Self-Attention and Transformers Explained Step by Step
Compute softmax(QK^T/sqrt(d_k))V by hand, see why the scaling matters, then add causal masks, multiple heads and a KV cache memory budget.
~10 min readread →
Vanishing and Exploding Gradients: Causes, Init and Fixes
Why gradients vanish or explode in deep networks, measured layer by layer, and how He and Xavier init, residuals and clipping fix it.
~9 min readread →
Go Buffered vs Unbuffered Channels: Interview Guide
When a Go channel send blocks, what buffering changes, who closes a channel, and how select, nil channels and timeouts fit together.
~8 min readread →
Go Context: Cancellation, Timeouts and Deadlines
How context cancellation propagates through a Go call tree, why cancel must always be called, and how to stop goroutines on a deadline.
~7 min readread →
Go Error Wrapping: %w, errors.Is and errors.As
How fmt.Errorf with %w builds an error chain in Go, when to use errors.Is versus errors.As, and how to design sentinel and typed errors.
~7 min readread →
Goroutines vs OS Threads: How the Go Scheduler Works
How goroutines differ from OS threads, how the GMP scheduler maps them onto CPUs, and what GOMAXPROCS, preemption and syscalls change.
~8 min readread →
Go Data Races: Mutex, WaitGroup and the Race Detector
What counts as a data race in Go, how sync.Mutex and WaitGroup fix it, and how go test -race finds the race before production does.
~7 min readread →
Go Interfaces and the Nil Error That Is Not Nil
Why a nil pointer returned as an error makes err != nil true in Go, how interface values store type and value, and how to avoid it.
~7 min readread →
Go Slices: len, cap, append and Shared Backing Arrays
How a Go slice header works, when append reallocates, why two slices can overwrite each other, and how to copy safely with Clone.
~7 min readread →
Go Worker Pools and Goroutine Leaks Explained
How to bound concurrency in Go with a worker pool or errgroup, why early returns leak goroutines, and how to find leaks with pprof.
~7 min readread →
Kafka Consumer Groups and Rebalancing Explained
How Kafka consumer groups share partitions, what triggers a rebalance, and how cooperative assignment and static membership cut downtime.
~8 min readread →
Kafka Exactly-Once Semantics and Transactions Explained
How Kafka transactions make consume-transform-produce exactly-once, how zombie fencing and read_committed work, and where the guarantee ends.
~8 min readread →
Kafka Idempotent Producer, Batching and linger.ms
How the Kafka idempotent producer stops duplicates from retries, what it cannot dedupe, and how batch.size, linger.ms and compression work.
~8 min readread →
Kafka Offset Commits and Delivery Semantics Explained
How Kafka consumers commit offsets, why commit order decides at-most-once or at-least-once, and how to get exactly-once effects.
~8 min readread →
Kafka Partitions, Offsets and Message Ordering Explained
How Kafka partitions and offsets work, why ordering is only per partition, and how keys keep each entity's events in sequence.
~9 min readread →
Kafka Poison Messages, Retries and Dead Letter Topics
Why one bad Kafka record can block a whole partition, and how to handle it with error classification, bounded retries and a dead letter topic.
~9 min readread →
Kafka Replication, ISR and acks=all: Durability Explained
How Kafka replicates partitions, what the ISR and high watermark mean, and how acks=all with min.insync.replicas prevents data loss.
~8 min readread →
Kafka Retention vs Log Compaction: How Old Data Is Removed
How Kafka deletes old segments by time or size, how log compaction keeps the latest value per key, and how tombstones delete keys.
~8 min readread →
Embeddings and Vector Search: AI Engineer Interview Guide
What embeddings are, how cosine similarity and approximate nearest neighbour indexes work, and when to add keyword search and reranking.
~8 min readread →
How to Evaluate LLM Applications: Evals and LLM Judges
Build an eval suite for an LLM app: golden datasets, code-based checks, LLM-as-judge calibration, retrieval metrics and regression gates in CI.
~8 min readread →
Fine-Tuning vs RAG: When to Use Each in LLM Apps
Fine-tuning changes how a model behaves; RAG changes what it knows at request time. A decision guide with data prep, costs and failure cases.
~9 min readread →
LLM Function Calling and Agent Loops Explained
How LLM tool use works: schemas, the call-execute-return loop, validation, error results, step limits and when an agent beats a workflow.
~8 min readread →
Prompt Injection Attacks and Defenses for LLM Apps
Direct and indirect prompt injection, why prompts alone cannot stop it, and layered defenses: tool policy, confirmation and output filtering.
~9 min readread →
How to Design a RAG Pipeline: Chunking, Retrieval and Prompts
A step-by-step RAG design for interviews: ingestion, structure-aware chunking, hybrid retrieval, grounded prompts with citations and evaluation.
~9 min readread →
How to Reduce LLM Hallucinations in Production
Why LLMs hallucinate and the layered fixes that work: grounding, permission to abstain, citations, structured output and automatic claim checks.
~8 min readread →
LLM Tokens, Temperature and Top-p Sampling Explained
How LLMs turn text into tokens, why the context window is a shared budget, and what temperature, top-k and top-p actually do to the next token.
~8 min readread →
Bias-Variance Tradeoff Explained: ML Interview Guide
What bias and variance really measure, how to read validation and learning curves, and which fix to reach for when a model underfits or overfits.
~9 min readread →
Cross-Validation and Data Leakage in Machine Learning
How k-fold cross-validation works, which splitter suits grouped or time data, and how leakage turns pure noise into an 85% accurate model.
~8 min readread →
Gradient Descent Explained: Batch vs SGD vs Mini-Batch
How gradient descent updates weights, how batch, stochastic and mini-batch differ, and why learning rate and feature scaling decide convergence.
~9 min readread →
Imbalanced Classification: Class Weights, SMOTE and PR-AUC
How to train and evaluate a classifier with rare positives: PR-AUC over accuracy, class weights vs thresholds, and resampling without leakage.
~8 min readread →
Logistic Regression Interview Questions: Sigmoid, Log Loss, Odds
How logistic regression turns a linear score into a probability, why it uses log loss, how to read odds ratios and what separation breaks.
~8 min readread →
Overfitting and L1 vs L2 Regularization Explained with Code
How to spot overfitting, why L1 zeroes weights while L2 only shrinks them, and how scaling, early stopping and dropout fit into regularization.
~9 min readread →
Precision vs Recall and F1 Score: ML Interview Guide
Precision, recall and F1 from the confusion matrix, how the threshold trades one for the other, and how to pick one that meets a target.
~8 min readread →
Random Forest vs Gradient Boosting: Bagging vs Boosting
Why a random forest averages away variance while gradient boosting chips away bias, with runnable code, early stopping and when to choose each.
~8 min readread →
Batch vs Online Inference: Choosing How to Serve a Model
When to score models in a nightly batch job and when behind a low-latency API, with tail-latency budgets, fallbacks and the hybrid pattern.
~8 min readread →
CI/CD for Machine Learning: Pipelines and Continuous Training
How CI, CD and continuous training fit together for ML, which tests gate a pipeline, retraining triggers, and Google's MLOps maturity levels.
~8 min readread →
Data Drift vs Concept Drift: Detecting Drift with PSI and KS
How data drift, concept drift and prediction drift differ, how PSI and the KS test measure them, and why p-value alerts drown your team in noise.
~8 min readread →
LLMOps: Prompt Versioning and Evaluation Gates in CI
Treat prompts as versioned releases: register and alias them in MLflow, trace every call, and block regressions with an evaluation gate in CI.
~7 min readread →
MLflow Experiment Tracking and Model Registry Explained
Log params, metrics and models with MLflow 3, compare runs with search_runs, and promote or roll back models by moving registry aliases.
~7 min readread →
Reproducible ML: Versioning Data, Code and Models
What it takes to rebuild a model months later: code commit, data snapshot and hash, config, seeds, environment and the registered artifact.
~7 min readread →
Shadow, Canary and A/B Deployments for ML Models
How shadow mode, canary releases and A/B tests de-risk a new model, what each can measure, sticky user bucketing, and rolling back safely.
~8 min readread →
Training-Serving Skew and Feature Stores Explained
Why models that ace offline tests fail live: duplicated feature code, refitted scalers, future-leaking joins, and how feature stores stop them.
~8 min readread →
Next.js App Router vs Pages Router: Interview Guide
How the App Router differs from the Pages Router in Next.js 15, how data fetching maps across, and how to migrate one route at a time.
~8 min readread →
Next.js Caching and Revalidation: The Four Layers Explained
Request memoization, the Data Cache, the Full Route Cache and the Router Cache in Next.js 15, and how to debug a page that shows stale data.
~8 min readread →
Fixing Next.js Hydration Errors: Causes and Solutions
Why React reports that server HTML did not match the client in Next.js 15, how to find the cause, and fixes for dates, browser APIs and nesting.
~8 min readread →
Next.js Middleware: Auth Redirects, Matchers and Limits
What Next.js 15 middleware can do, how matchers decide where it runs, and why real authorisation still belongs next to your data.
~7 min readread →
Next.js Server Actions: Forms, Mutations and Security
How Server Actions turn a function into a POST endpoint in Next.js 15, how to build forms with useActionState, and how to secure every action.
~7 min readread →
Next.js Server vs Client Components: When to Use Each
How Server and Client Components render in the Next.js 15 App Router, where to put use client, and how to keep secrets out of the bundle.
~7 min readread →
Next.js SSR vs SSG vs ISR: Rendering Strategies Explained
When Next.js 15 renders a page at build time, per request or with background regeneration, and how to prove which one a route uses.
~7 min readread →
Next.js Streaming with loading.tsx, Suspense and error.tsx
How loading.tsx and Suspense stream a Next.js 15 page, where error.tsx catches failures, and why a slow layout or late notFound breaks the plan.
~8 min readread →
Redis Caching Patterns, Invalidation and Cache Stampedes
Cache-aside, write-through and write-behind with Redis, a safe invalidation order, and working code that stops a cache stampede.
~9 min readread →
Redis Data Structures and When to Use Each One
Strings, hashes, lists, sets, sorted sets, streams, HyperLogLog and bitmaps: what each Redis type costs and which interview use case it fits.
~8 min readread →
Redis Distributed Locks: SET NX PX, Fencing and Redlock
Build a correct Redis lock with SET NX PX and a token-checked release, add fencing tokens, and explain the Redlock algorithm and its critique.
~8 min readread →
Redis Eviction Policies and Key Expiry: LRU, LFU and TTL
How Redis expires keys lazily and actively, what each maxmemory-policy evicts, and how approximated LRU and LFU choose a victim.
~8 min readread →
Redis Persistence: RDB vs AOF and fsync Trade-offs
How RDB snapshots and the append-only file work, how much data each appendfsync setting can lose, and how to enable AOF without losing data.
~8 min readread →
Redis Rate Limiting with Lua: Fixed Window to Token Bucket
Fixed window, sliding log and token bucket rate limiters in Redis, why they must be atomic, and tested Lua scripts for each one.
~8 min readread →
Redis Replication, Sentinel and Cluster Hash Slots
How Redis replicates asynchronously, how Sentinel fails over, and how Cluster shards keys into 16,384 hash slots with MOVED and ASK redirects.
~8 min readread →
Why Is Redis Single-Threaded? Event Loop and I/O Threads
Why one Redis thread handles huge request rates, what io-threads and background threads change, and which commands block every client.
~8 min readread →
Angular Defer Blocks and Lazy Rendering
Load template regions on demand with @defer, choose a trigger, and use placeholders without delaying critical content.
~2 min readread →
Angular Global Error Handling
Catch uncaught errors with a custom ErrorHandler, distinguish client from HTTP errors, and surface safe messages to users.
~2 min readread →
Angular Host Directives and Composition
Attach behavior to elements with attribute directives, bind to the host with the host property, and compose directives with hostDirectives.
~2 min readread →
Angular Pure and Impure Pipes
Understand why pure pipes run only when inputs change, what makes a pipe impure, and how to avoid the performance cost.
~3 min readread →
Angular Resource API for Async Data
Load data reactively with the resource API, track loading and error state as signals, and cancel stale requests automatically.
~2 min readread →
Angular Signal Forms Overview
Model forms as signals, bind fields in the template, and reason about validation and derived state in a signal-driven form.
~2 min readread →
Angular SSR and Hydration Consistency
Server-render Angular apps, hydrate without mismatches, and avoid the DOM and timing assumptions that break rendering.
~2 min readread →
Angular Template-Driven vs Reactive Forms
Compare template-driven and reactive forms, choose the right one for a screen, and avoid mixing two sources of truth.
~2 min readread →
Angular Zoneless Change Detection
Run Angular without zone.js, drive updates with signals, and understand which async sources still schedule change detection.
~2 min readread →
AWS CloudFront Caching and Invalidation
Control CloudFront TTLs, invalidate or version content, and use an origin shield to protect the origin.
~2 min readread →
AWS DynamoDB Query vs Scan
Read by key with Query, avoid full-table Scans, and add indexes to serve the access patterns you actually have.
~2 min readread →
AWS ECS vs EKS
Compare ECS and EKS for running containers on AWS, and choose by control, portability and team capability.
~2 min readread →
AWS EventBridge Rules and Scheduling
Match events and run schedules with EventBridge, route to targets, and handle delivery failures.
~2 min readread →
AWS IAM Role Assumption and Temporary Credentials
Assume roles with STS, separate trust from permission policies, and use temporary credentials instead of long-lived keys.
~2 min readread →
AWS Lambda Cold Starts and Warm Reuse
Reduce cold-start latency with smaller packages, provisioned concurrency and initialization outside the handler.
~2 min readread →
AWS RDS Multi-AZ vs Read Replicas
Use Multi-AZ for failover availability and read replicas for read scaling, and stop confusing the two.
~2 min readread →
AWS S3 Lifecycle Policies
Move objects to cheaper storage classes and expire them automatically with S3 lifecycle rules.
~2 min readread →
AWS Secrets Manager and Rotation
Store secrets centrally, rotate credentials automatically with a two-user pattern, and fetch them at runtime.
~2 min readread →
Behavioral: Building a Career Growth Plan
Show how you identified the next level's expectations, gathered evidence, and sought feedback instead of waiting for promotion.
~2 min readread →
Behavioral: Cross-Team Collaboration
Answer questions about working across teams by aligning on outcomes, defining interfaces and using a clear escalation path.
~2 min readread →
Behavioral: Working with a Difficult Stakeholder
Show how you understand a stakeholder's goal, present data and options, and agree on a decision process instead of arguing.
~2 min readread →
Behavioral: Influencing Without Authority
Show how you built credibility, framed ideas in others' interests, and used a small pilot to win support without a mandate.
~2 min readread →
Behavioral: Managing Scope Creep
Make trade-offs explicit, protect the milestone, and renegotiate scope instead of silently absorbing it.
~2 min readread →
Behavioral: Onboarding onto a New Team
Show how you learned a new system quickly, landed a small early win, and built relationships instead of changing everything at once.
~2 min readread →
Behavioral: Communicating on Remote Teams
Show how you default to written communication, provide context asynchronously, and keep distributed work moving across timezones.
~2 min readread →
Behavioral: Negotiating Compensation
Negotiate from a researched range, discuss total compensation, and keep the conversation collaborative without ultimatums.
~2 min readread →
Behavioral: Advocating for Technical Debt Work
Make the case for paying down technical debt by tying it to incidents and velocity, and proposing small, incremental work.
~2 min readread →
Docker Build Args vs Environment and Secrets
Use build args for build-time configuration, keep secrets out of them, and understand how they interact with the cache.
~2 min readread →
Docker BuildKit and Cache Mounts
Speed up image builds with BuildKit cache mounts, multi-stage builds and dependency-first layer ordering.
~2 min readread →
Docker Compose Profiles
Start only the services you need with Compose profiles, and keep the default set small for focused local development.
~2 min readread →
Docker Distroless and Minimal Images
Ship images without a shell or package manager, copy only the runtime, and accept the debugging trade-off.
~2 min readread →
Docker Image Vulnerability Scanning
Scan images for known CVEs in CI, set a policy that blocks the build, and rebuild when base images are patched.
~2 min readread →
Docker init, PID 1 and Signal Handling
Why the first process in a container must reap children and forward signals, and how to avoid zombies and ignored shutdowns.
~2 min readread →
Docker Registry Authentication
Authenticate to private registries with credential helpers, pull secrets in Kubernetes, and scoped tokens.
~2 min readread →
Docker Restart Policies
Choose between no, on-failure, always and unless-stopped, and combine a policy with health checks to avoid crash loops.
~2 min readread →
Docker tmpfs Mounts
Store ephemeral, sensitive data in memory with tmpfs mounts, and set size limits so memory use stays bounded.
~2 min readread →
Bit Manipulation Patterns for Interviews
Set, test and clear bits, exploit XOR properties, and count set bits with the Brian Kernighan trick.
~2 min readread →
Git Detached HEAD
What a detached HEAD is, when it happens, and how to keep commits made in that state.
~2 min readread →
Git Hooks and Local Automation
Automate checks with client and server hooks, share them through a framework, and enforce the same rules in CI where they cannot be bypassed.
~2 min readread →
Git LFS for Large Files
Track large binaries with Git LFS, keep pointer files in the repository, and plan for LFS storage and access.
~2 min readread →
Git Partial and Shallow Clones
Fetch less history and content with shallow and partial clones, and understand what you give up.
~2 min readread →
Git Remote-Tracking Branches
Understand remote-tracking refs, the difference between fetch and pull, and how tracking branches stay in sync.
~2 min readread →
Git Signed Commits and Tags
Sign commits and tags, verify signatures, and enforce them to prove who authored a change.
~2 min readread →
Git Submodules vs Subtrees
Embed another repository with submodules or subtrees, and choose based on how often it changes and who owns it.
~2 min readread →
Git Tags and Releases
Mark releases with annotated tags, push them explicitly, and treat a tag as immutable.
~2 min readread →
Git Worktrees
Check out several branches at once in separate directories with git worktree, sharing one object database.
~2 min readread →
CSS aspect-ratio and Layout Stability
Reserve space for media with aspect-ratio, combine it with object-fit, and avoid the layout shift the old padding hack caused.
~2 min readread →
The CSS :has() Selector
Style a parent based on its children with :has(), handle form states, and use it without hurting performance.
~2 min readread →
CSS Cascade Layers
Control the cascade order with @layer, keep specificity low, and understand how unlayered styles fit in.
~2 min readread →
CSS Dark Mode with prefers-color-scheme
Support light and dark themes with prefers-color-scheme and custom properties, and avoid the flash of the wrong theme.
~2 min readread →
Flexbox vs Grid: Choosing a Layout
Use flexbox for one-dimensional flows and grid for two-dimensional layouts, and know when each is the simpler tool.
~2 min readread →
Inline, Block and Inline-Block
Understand the default display types, how they affect sizing and flow, and why some properties are ignored on inline elements.
~2 min readread →
CSS Print Styles
Style for print with @media print, hide navigation, and control page breaks so documents read well on paper.
~2 min readread →
CSS Text Overflow and Ellipsis
Truncate text with an ellipsis, clamp multiple lines, and fix the flexbox case where truncation refuses to happen.
~2 min readread →
CSS Transforms and Animations
Animate transform and opacity for smooth motion, use transitions and keyframes, and respect reduced-motion preferences.
~2 min readread →
Java Generics Wildcards and PECS
Use ? extends T for producers and ? super T for consumers, and understand why List<String> is not a List<Object>.
~2 min readread →
JavaScript Array Methods: Mutating Versus Returning New
Know which array methods change the original in place and which return a new array, and pick the right one to avoid shared-state bugs.
~2 min readread →
JavaScript Date and Timezone Pitfalls
Parse and format dates without timezone surprises: zero-based months, date-only versus date-time parsing, and why UTC storage avoids drift.
~3 min readread →
JavaScript Number Precision and BigInt
Why 0.1 + 0.2 is not 0.3, where safe integer range ends, and when BigInt is the right tool for large identifiers and money.
~2 min readread →
JavaScript Object Destructuring and Defaults
Destructure objects with renamed bindings and defaults, and learn why only undefined triggers a default while null keeps its value.
~2 min readread →
JavaScript Optional Chaining and Nullish Coalescing
Short-circuit safely with optional chaining and choose ?? over || when 0, empty strings and false are valid values.
~2 min readread →
JavaScript Timeouts with Promise.race
Race a promise against a timer to enforce a deadline, and clean up the timer plus the losing work instead of leaving it running.
~3 min readread →
JavaScript RegExp Stateful Flags and lastIndex
Why a global or sticky RegExp can alternate between matching and failing, and how lastIndex and the g/y flags interact with test and exec.
~2 min readread →
JavaScript Rest and Spread Gotchas
Use spread and rest correctly, and avoid the shallow-copy trap where nested objects are still shared between the original and the copy.
~2 min readread →
JavaScript Symbols and Well-Known Symbols
Create unique property keys, customize object behavior with well-known symbols, and understand why symbols vanish from JSON and Object.keys.
~2 min readread →
Kubernetes ConfigMap Update Behavior
Understand why ConfigMap changes reach volumes but not environment variables, and how to roll a Deployment deliberately.
~2 min readread →
Kubernetes emptyDir Volumes
Share scratch space between containers in a pod with emptyDir, choose the backing medium, and bound its size.
~2 min readread →
Kubernetes Gateway API for Ingress
Route traffic with GatewayClass, Gateway and HTTPRoute, and understand how the Gateway API improves on Ingress.
~2 min readread →
Kubernetes Horizontal Pod Autoscaling
Scale replicas from metrics with the HPA, set sensible targets, and stabilize against flapping.
~2 min readread →
Kubernetes Init Containers
Run setup and dependency waits in init containers before the app starts, and keep startup logic out of the app itself.
~2 min readread →
Kubernetes Pod Security Admission
Enforce pod hardening with the Pod Security Admission levels, and migrate workloads off the removed PodSecurityPolicy.
~2 min readread →
Kubernetes Pod Topology Spread
Spread replicas across zones and nodes with topology spread constraints, and balance availability against scheduling failure.
~2 min readread →
Kubernetes Resource Quotas and LimitRanges
Cap a namespace's total resources with a quota and set per-container defaults with a LimitRange.
~2 min readread →
Kubernetes Service Types
Choose ClusterIP, NodePort, LoadBalancer or a headless Service, and know what each exposes.
~2 min readread →
Microservices Anti-Corruption Layer
Protect a service's domain model from a foreign or legacy model with a translation layer at the boundary.
~2 min readread →
Microservices API Versioning and Evolution
Evolve service APIs without breaking consumers using additive changes, explicit versioning and consumer-driven contracts.
~2 min readread →
Microservices Backend for Frontend
Use a per-client BFF to aggregate services and shape responses, without letting it become a shared god service.
~2 min readread →
Microservices Distributed Locking
Coordinate exclusive access across instances with leases and fencing, and prefer partitioning or idempotency when you can.
~2 min readread →
Microservices Event Sourcing
Store events as the source of truth, rebuild state by replay, and manage versioning with snapshots.
~2 min readread →
Microservices Health Check Endpoints
Separate liveness from readiness, keep deep dependency checks off the restart path, and avoid the restart loop.
~2 min readread →
Microservices Schema Registry
Register event schemas centrally, enforce compatibility on publish, and version them so consumers are never surprised.
~2 min readread →
Microservices Sidecar Proxies
Move cross-cutting networking concerns into a co-located proxy, configure them centrally, and watch for hidden retries.
~2 min readread →
Microservices Strangler Fig Migration
Replace a monolith incrementally by routing slices to new services, avoiding a big-bang rewrite.
~2 min readread →
MongoDB Bulk Writes
Batch inserts and updates with bulkWrite, choose ordered or unordered, and handle partial failures correctly.
~2 min readread →
MongoDB Capped Collections
Use capped collections for fixed-size, insertion-ordered logs, and know why documents cannot grow.
~2 min readread →
MongoDB Change Streams and Resume Tokens
React to inserts and updates with change streams, persist resume tokens, and handle invalidate and failover correctly.
~2 min readread →
MongoDB Collation and Case-Insensitive Queries
Use collations for case- and accent-insensitive matching, and make the index collation match the query collation.
~2 min readread →
MongoDB GridFS for Large Files
Store files larger than the 16 MB document limit with GridFS, streaming uploads and downloads and cleaning up orphaned chunks.
~2 min readread →
MongoDB Query Hints and Index Selection
Diagnose a poor index choice, force one with hint, and remove the hint once the planner is fixed.
~2 min readread →
MongoDB Projections and Covered Queries
Return only the fields you need, exclude _id when unused, and build a covering index that answers a query without fetching documents.
~2 min readread →
MongoDB Text Search Indexes
Create a weighted text index, query with $text and textScore, and understand the limits of MongoDB's built-in search.
~2 min readread →
MongoDB Time-Series Collections
Store metrics and events in time-series collections, set the meta field and granularity, and query with time bounds.
~2 min readread →
Networking: DNS Caching and TTL
Understand positive and negative caching, why changes are not instant, and how TTL trades propagation speed against query load.
~2 min readread →
Networking: DNS Record Types
Read and choose DNS records: A and AAAA for addresses, CNAME for aliases, and MX and TXT for mail and verification.
~2 min readread →
Networking: HTTP Redirects
Choose between 301, 302, 307 and 308, know which preserve the request method, and avoid caching and loop mistakes.
~2 min readread →
HTTP/3 and QUIC Transport
How HTTP/3 runs over QUIC on UDP, why it removes transport head-of-line blocking, and when it helps in practice.
~2 min readread →
Networking: IP Subnetting and CIDR
Read CIDR notation, compute usable host ranges, and design non-overlapping subnets for a VPC.
~2 min readread →
Networking: L4 vs L7 Load Balancing
Choose between a transport-layer and an application-layer load balancer, and understand what each can and cannot route on.
~2 min readread →
Networking: MTU and Fragmentation
Why the MTU limits packet size, how path MTU discovery avoids fragmentation, and why tunnels cause black-hole connections.
~2 min readread →
Networking: TCP Flow Control
How the receive window stops a fast sender from overrunning a slow receiver, and how it differs from congestion control.
~2 min readread →
Networking: The TLS Handshake
How TLS negotiates keys and certificates, what TLS 1.3 improves, and the certificate mistakes that break HTTPS.
~2 min readread →
Node.js Caching Layers and Invalidation
Choose where to cache, set TTLs, avoid caching errors, and protect a cold cache with single-flight loading.
~2 min readread →
Node.js Clustering Across CPU Cores
Use cluster to run several workers on all cores, restart crashed workers, and understand shared-port and shared-state limits.
~2 min readread →
Node.js Password Hashing with scrypt
Store passwords as salted hashes with a slow key-derivation function, and compare candidates in constant time.
~2 min readread →
Node.js ESM and CommonJS Interop
Choose between ESM and CommonJS, import CJS defaults from ESM, and reach ESM from CJS with dynamic import.
~2 min readread →
Node.js HTTP Security Headers
Set defensive HTTP headers centrally: content type protection, a content security policy, referrer policy and HSTS over HTTPS.
~2 min readread →
Node.js Retries with Backoff and Jitter
Retry only transient failures, space attempts with exponential backoff plus jitter, and cap attempts and total time.
~2 min readread →
Node.js Structured Logging
Emit JSON logs with levels and correlation ids, keep them machine-readable, and never log secrets or personal data.
~2 min readread →
Node.js URL and URLSearchParams
Build and parse URLs with the WHATWG URL API instead of string concatenation, and validate the host before fetching.
~2 min readread →
Node.js Response Compression with zlib
Compress HTTP responses with gzip or brotli streams, negotiate the encoding, and avoid compressing data that is already compressed.
~2 min readread →
Operating Systems: CPU Cache Locality
Improve performance with spatial and temporal locality, avoid pointer chasing, and understand false sharing between threads.
~2 min readread →
Copy-on-Write Memory and fork
How copy-on-write lets fork share pages until a write, why RSS can be misleading, and the implications for memory and latency.
~2 min readread →
Operating Systems: epoll and select
How select, poll and epoll report I/O readiness, and the difference between level- and edge-triggered notifications.
~2 min readread →
Operating Systems: I/O Models
Compare blocking, non-blocking, multiplexed and asynchronous I/O, and why the choice drives server scalability.
~2 min readread →
Operating Systems: Journaling and Durability
How write-ahead journaling keeps a filesystem consistent after a crash, and why durability needs an explicit fsync.
~2 min readread →
Operating Systems: Memory Allocation
Compare stack and heap allocation, how the allocator manages the heap, and the fragmentation and lifetime bugs that follow.
~2 min readread →
Operating Systems: Signals
Use SIGTERM for graceful shutdown, respect the limits of signal handlers, and know which signals cannot be caught.
~2 min readread →
Operating Systems: Swap and Thrashing
How swapping extends memory, when it becomes thrashing, and how overcommit and the OOM killer respond to exhaustion.
~2 min readread →
Operating Systems: Thread Pools
Bound concurrency with a fixed pool and a queue, size it for the workload, and avoid the unbounded backlog.
~2 min readread →
Python asyncio.gather and Timeouts
Run coroutines concurrently with asyncio.gather, enforce timeouts, and handle partial failures and cancellation correctly.
~2 min readread →
React Live Regions and Screen Reader Announcements
Announce dynamic updates to assistive technology with polite and assertive live regions, and avoid the mistakes that silence them.
~2 min readread →
React Context Splitting for Performance
Stop a single context value from re-rendering every consumer by splitting state and dispatch and memoizing the provider value.
~2 min readread →
React lazy Loading and Code Splitting
Split bundles with lazy and Suspense, work with default exports, and place boundaries so a chunk loads only when needed.
~2 min readread →
React Portals and Event Bubbling
Render outside the parent DOM with createPortal while events keep bubbling through the React tree, and manage focus and z-index.
~2 min readread →
React Server Components and the Client Boundary
Split server and client components, mark interactive leaves with use client, and keep props serializable across the boundary.
~2 min readread →
React StrictMode and Double-Invoked Effects
Understand why StrictMode runs effects twice in development, how it surfaces missing cleanup, and why disabling it is the wrong fix.
~2 min readread →
React Form Actions with useActionState
Manage form submission, pending state and server errors with useActionState instead of hand-rolled loading flags.
~2 min readread →
React useOptimistic and Instant Feedback
Show the expected result immediately with useOptimistic, then reconcile with the server and roll back cleanly on failure.
~2 min readread →
React Imperative Handles with useImperativeHandle
Expose a minimal imperative API from a component with forwardRef and useImperativeHandle instead of leaking the DOM node.
~2 min readread →
ServiceNow ACL Scripting and Access
Enforce access with ACLs, use scripted conditions carefully, and test as the actual user to verify.
~2 min readread →
ServiceNow Caching and Invalidation
Understand what the platform caches, when a change takes effect, and how to flush caches consistently across nodes.
~2 min readread →
ServiceNow Dictionary and Field Audit
Define fields in the dictionary, use per-table overrides, and enable audit on the fields that need a history.
~2 min readread →
ServiceNow g_form and Client Script Design
Use the client form API for presentation, keep validation on the server, and avoid heavy client scripts.
~2 min readread →
ServiceNow Notification Controls
Send notifications through events and business rules, gate them with conditions, and prevent the notification storm that floods users.
~2 min readread →
ServiceNow Record Producers
Collect input with a catalog form and create the right record, and know the limits when the target span multiple tables.
~2 min readread →
ServiceNow REST API Design
Expose data through Scripted REST or the Table API, version the contract, and avoid leaking internal tables.
~2 min readread →
ServiceNow Scheduled Jobs
Run recurring server-side work with scheduled jobs, avoid overlap and long runs, and log enough to debug failures.
~2 min readread →
ServiceNow Update Sets and Conflicts
Move configuration with update sets, resolve collisions in order, and avoid the manual edits that break promotion.
~2 min readread →
Spring @Async and Executor Configuration
Run methods asynchronously with @Async, configure a bounded executor, and handle exceptions and the proxy boundary.
~2 min readread →
Spring Boot Caching Abstraction
Cache method results with @Cacheable, choose keys and TTLs, and evict on writes without the self-invocation trap.
~2 min readread →
Spring Declarative HTTP Clients
Define outbound HTTP as an annotated interface with @HttpExchange, create the proxy, and configure timeouts and errors.
~2 min readread →
Spring Boot Problem Details for APIs
Return consistent RFC 7807 error responses, map exceptions centrally, and avoid leaking internals to clients.
~2 min readread →
Spring Boot REST Pagination
Page results with Pageable, always sort stably, and avoid the deep-offset slowdown on large tables.
~2 min readread →
Spring Boot Scheduled Tasks
Run recurring work with @Scheduled, coordinate across instances, and avoid overlap and long-running jobs.
~2 min readread →
Spring Boot Testcontainers
Test against real databases and services in containers, manage their lifecycle, and isolate state between tests.
~2 min readread →
Spring Boot Distributed Tracing
Propagate trace context with Micrometer Tracing, correlate spans across services, and sample without overwhelming storage.
~2 min readread →
Spring Bean Validation Groups
Apply different validation rules for create and update with groups, and sequence checks with group order.
~2 min readread →
PostgreSQL CASE Expressions
Use simple and searched CASE for conditional values, ordering and aggregation, and avoid the NULL that a missing ELSE produces.
~2 min readread →
PostgreSQL Date Truncation and Ranges
Group by time with date_trunc, write range predicates with >= and < instead of BETWEEN, and handle timezones explicitly.
~2 min readread →
PostgreSQL Deadlocks and Retry
Prevent deadlocks with a consistent lock order and short transactions, and retry the ones you cannot prevent.
~2 min readread →
PostgreSQL Generated Columns
Keep derived values consistent with generated columns, choose STORED or virtual, and index a stored derived value.
~2 min readread →
SQL WHERE vs HAVING
Filter rows with WHERE before grouping and groups with HAVING after, and understand why the placement changes cost and correctness.
~2 min readread →
PostgreSQL JSONB Columns and Indexing
Store and query semi-structured data with jsonb, extract fields with -> and ->>, and index the queries you actually run.
~2 min readread →
PostgreSQL Recursive CTEs for Hierarchies
Walk parent-child data with WITH RECURSIVE, guard against infinite loops, and understand the anchor and recursive terms.
~2 min readread →
PostgreSQL Self-Joins
Join a table to itself to compare rows, walk a hierarchy, or find duplicates, and avoid the accidental cross product.
~2 min readread →
PostgreSQL Set Operations
Combine result sets with UNION, UNION ALL, INTERSECT and EXCEPT, and know when deduplication changes cost or meaning.
~2 min readread →
System Design: Backpressure and Load Shedding
Protect a service from overload by bounding queues, signaling producers to slow down, and shedding low-priority work.
~2 min readread →
System Design: Bloom Filters
Use a Bloom filter to skip lookups with a tiny memory footprint, and understand its false-positive-only guarantee.
~2 min readread →
System Design: Idempotent APIs
Make retried requests safe with idempotency keys, store the result per key, and return the original response on a repeat.
~2 min readread →
System Design: Leader Election and Fencing
Elect a single leader with leases or consensus, use fencing tokens to reject stale leaders, and avoid split brain.
~2 min readread →
System Design: Notification System
Ingest events, respect preferences, deduplicate and deliver across channels with retries and provider failover.
~2 min readread →
System Design: Presence Tracking
Track online status with heartbeats and TTLs, derive presence instead of storing it, and avoid fanning out to every client.
~2 min readread →
System Design: Schema Evolution
Evolve stored and message schemas with additive changes, expand-contract migrations, and reader tolerance across services.
~2 min readread →
System Design: Time-Series Metrics
Ingest metrics with bounded cardinality, roll up raw samples, and set retention tiers so storage stays predictable.
~2 min readread →
System Design: URL Shortener
Generate short codes from ids, keep the read path fast and cached, and handle collisions and analytics.
~2 min readread →
Testing Time with an Injected Clock
Inject a clock instead of calling the system time, freeze it in tests, and remove the sleeps that make tests flaky.
~2 min readread →
Code Coverage and Its Limits
Read line and branch coverage as a signal, not a goal, and avoid the tests that chase the number without checking behavior.
~2 min readread →
Scoping End-to-End Tests
Reserve end-to-end tests for critical user journeys, use stable selectors, and avoid duplicating coverage the lower tests already have.
~2 min readread →
Testing Error Paths
Test failures and edge inputs deliberately, assert the error type and message, and stop the happy path from hiding bugs.
~2 min readread →
Unit and Integration Test Balance
Separate fast isolated unit tests from integration tests that use real dependencies, and find the balance that catches real bugs.
~2 min readread →
Parallel Test Isolation
Run tests in parallel without interfering by removing shared state, isolating resources, and randomizing order.
~2 min readread →
Red, Green, Refactor
Write a failing test first, make it pass minimally, then refactor under green, and understand why the order matters.
~2 min readread →
Snapshot Tests Worth Reviewing
Keep snapshots small and intentional, review every diff, and stop large snapshots from becoming rubber-stamped assertions.
~2 min readread →
Test Data Builders and Object Mothers
Build valid test objects with defaults and override only what a test cares about, to keep tests readable and robust.
~2 min readread →
TypeScript Abstract Classes and Contracts
Share behavior with abstract classes, enforce required members, and decide when an interface or composition is the better contract.
~2 min readread →
TypeScript Declaration Files and Untyped Packages
Write .d.ts files for JavaScript packages, declare modules, and expose types with the package.json types field.
~2 min readread →
TypeScript Enums vs Union Types
Compare enums with unions of string literals: runtime cost, serialization, exhaustiveness and which one fits application code.
~3 min readread →
TypeScript Generic Defaults and Parameter Order
Give type parameters defaults to make them optional, and order them so inference still works without explicit arguments.
~2 min readread →
TypeScript Index Signatures and Constraints
Model keyed collections with index signatures, type the value side, and avoid the loose any that hides real type errors.
~3 min readread →
TypeScript Key Remapping in Mapped Types
Rename mapped-type keys with an as clause, filter keys by mapping to never, and build getter and prefixed types generically.
~2 min readread →
TypeScript Strict Compiler Flags
Turn on strict checks, know which flags strict bundles, and layer the non-strict extras such as noUncheckedIndexedAccess.
~2 min readread →
TypeScript Template Literal Types
Compose string types with template literals, interpolate unions to generate combinations, and understand how they stay type-level only.
~2 min readread →
TypeScript this Types and Fluent APIs
Use polymorphic this return types for builders, keep chaining correct through subclasses, and constrain this parameters.
~2 min readread →
Can't bind to 'ngModel' since it isn't a known property of 'input' in Angular
Fix Angular NG8002 Can't bind to 'ngModel' since it isn't a known property of 'input': import FormsModule, then fix formControl and inputs.
~7 min readread →
Angular 'Blocked by CORS Policy' on ng serve: Fix with proxy.conf.json
Fix 'blocked by CORS policy' errors when Angular ng serve calls a backend: proxy.conf.json, angular.json wiring and production CORS setup.
~7 min readread →
ExpressionChangedAfterItHasBeenCheckedError in Angular (NG0100)
Fix Angular NG0100 ExpressionChangedAfterItHasBeenCheckedError: why the dev-mode check fires, and data-flow fixes that beat setTimeout.
~8 min readread →
'app-x' is not a known element in Angular (NG8001): How to Fix It
Fix Angular NG8001 'app-x' is not a known element: standalone imports, selector typos, NgModule exports, schemas and TestBed setup.
~7 min readread →
NullInjectorError: No provider for X! in Angular (NG0201): How to Fix
Fix Angular NullInjectorError: No provider for X! (NG0201): read the injector path, add provideHttpClient(), providedIn root or a token.
~7 min readread →
Docker Container Exits Immediately: How to Debug It
Why a Docker container exits immediately: check the exit code, read docker logs, open a shell and fix a command that only starts a background job.
~5 min readread →
Docker 'exec format error': When the Image CPU Does Not Match
Fix 'exec format error' in Docker: confirm the CPU architecture mismatch with uname and docker inspect, then rebuild with the right --platform or buildx target.
~6 min readread →
Docker 'no space left on device': Safe Cleanup for Builds and Pulls
Fix Docker 'no space left on device' during build or pull: measure with docker system df, prune in a safe order, and cap logs and build cache.
~8 min readread →
Docker permission denied on /var/run/docker.sock: Fixes and Risks
Fix 'permission denied while trying to connect to the Docker daemon socket': docker group, re-login, rootless mode, contexts and a dead daemon.
~8 min readread →
Docker 'Bind for 0.0.0.0:8080 failed: port is already allocated' Fix
Fix Docker 'port is already allocated' and 'address already in use': find the container or process on the port, then remap or bind to 127.0.0.1.
~7 min readread →
Git: Your branch and 'origin/main' have diverged (Fix)
Fix 'Your branch and origin/main have diverged' and fatal: Need to specify how to reconcile divergent branches: merge, rebase or ff-only.
~7 min readread →
Git: failed to push some refs (fetch first, non-fast-forward)
Fix Git's error: failed to push some refs and ! [rejected] main -> main (fetch first): fetch, rebase or merge, and force-with-lease safely.
~7 min readread →
Git Permission denied (publickey) on GitHub: SSH Fix
Fix git@github.com: Permission denied (publickey) and Could not read from remote repository: test SSH, load keys, set IdentityFile, or use HTTPS.
~7 min readread →
Git fatal: refusing to merge unrelated histories (How to Fix)
Fix Git's fatal: refusing to merge unrelated histories: why it happens, when --allow-unrelated-histories is right, and safer alternatives.
~8 min readread →
How to Undo the Last Commit in Git: reset, amend, revert
How to undo the last commit in Git: git reset --soft, --mixed or --hard, commit --amend, git revert for pushed commits, and reflog recovery.
~7 min readread →
ClassNotFoundException vs NoClassDefFoundError in Java
ClassNotFoundException vs NoClassDefFoundError in Java: what each error means, why classes go missing at runtime and how to fix the classpath.
~8 min readread →
Java ConcurrentModificationException: Removing Items Safely
Fix java.util.ConcurrentModificationException when removing items in a loop: use removeIf or Iterator.remove, and see when concurrent lists help.
~7 min readread →
Java NullPointerException: Reading the Message and Fixing the Cause
Fix java.lang.NullPointerException by reading the helpful message, finding the null in the top stack frame and validating inputs early.
~8 min readread →
java.lang.OutOfMemoryError: Java Heap Space: Diagnosis and Fixes
Fix java.lang.OutOfMemoryError: Java heap space by checking -Xmx, capturing a heap dump and finding what retains memory in Eclipse MAT.
~8 min readread →
UnsupportedClassVersionError: Class File Version Mismatch in Java
Fix UnsupportedClassVersionError (class file version 65.0 vs 61.0) by matching the runtime JDK to your build or compiling with javac --release.
~8 min readread →
UnsupportedOperationException from Arrays.asList and List.of
Why Arrays.asList and List.of throw UnsupportedOperationException on add or remove, and how to choose a mutable copy or an immutable list.
~6 min readread →
JavaScript Array Sort Comparators
Sort arrays in place with a correct comparator, understand default string ordering and sort stability, and avoid the numeric and string traps.
~3 min readread →
JavaScript Async Iteration and Backpressure
Consume async generators with for await, propagate errors and pace a producer to a slow consumer without buffering the whole stream.
~3 min readread →
Fixing 'Blocked by CORS Policy' Errors in JavaScript fetch
Fix 'blocked by CORS policy' fetch errors: which headers the server must send, preflights, credentials, dev proxies and why no-cors fails.
~8 min readread →
TypeError: Cannot Read Properties of Undefined in JavaScript
Fix TypeError: Cannot read properties of undefined by finding which value is missing, reading the stack trace and repairing the data flow.
~8 min readread →
Cannot Use Import Statement Outside a Module: ESM vs CommonJS
Fix SyntaxError: Cannot use import statement outside a module in Node and browsers: type module, .mjs, require of ESM and __dirname in ESM.
~8 min readread →
JavaScript Custom Error Classes
Extend Error to carry a stable name and instanceof, preserve the underlying cause, and avoid the string-throwing mistakes interviewers look for.
~3 min readread →
TypeError: x Is Not a Function in JavaScript: Causes and Fixes
Fix TypeError: x is not a function in JavaScript: wrong imports, shadowed names, lost this, a missing semicolon or .map on a non-array.
~7 min readread →
RangeError: Maximum Call Stack Size Exceeded in JavaScript
Fix RangeError: Maximum call stack size exceeded: missing base cases, self-calling setters, circular data, huge spreads and deep recursion.
~8 min readread →
JavaScript Proxy Traps for Validation
Validate object writes with Proxy set and get traps, forward with Reflect and avoid the invariants that make a proxy lie about its target.
~3 min readread →
ReferenceError: x Is Not Defined vs undefined in JavaScript
Fix ReferenceError: x is not defined: typos, block scope, the TDZ, window or require missing in Node, and scripts that load in the wrong order.
~7 min readread →
JavaScript structuredClone and Transferables
Deep-clone Dates, Maps, Sets and cyclic graphs with structuredClone, and move ArrayBuffers between contexts instead of copying them.
~3 min readread →
SyntaxError: Unexpected Token '<' in JSON: Debugging fetch
Fix SyntaxError: Unexpected token '<' in JSON from fetch: the server sent HTML. Check res.ok and content-type, then read the body as text.
~7 min readread →
Uncaught (in promise): Fixing Unhandled Promise Rejections
Fix Uncaught (in promise) errors and Node crashes from unhandled rejections: missing await, async forEach, fire-and-forget and rethrown errors.
~7 min readread →
Kubernetes CrashLoopBackOff: Back-off restarting failed container
Fix Kubernetes CrashLoopBackOff: read the exit code, check kubectl logs --previous, fix command, config and probes, and understand backoff timing.
~9 min readread →
Kubernetes CreateContainerConfigError: Missing Config or Secret
Fix CreateContainerConfigError: read the kubectl describe event, repair missing ConfigMap or Secret names and keys, and use optional refs sparingly.
~5 min readread →
Kubernetes ImagePullBackOff: ErrImagePull, Failed to pull image
Fix Kubernetes ImagePullBackOff and ErrImagePull: read the pull error, then fix tag typos, imagePullSecrets, CPU architecture or Docker Hub rate limits.
~8 min readread →
Kubernetes OOMKilled and Exit Code 137: Fix Memory Limits
Fix Kubernetes OOMKilled (exit code 137): read lastState.terminated.reason, tell node eviction from the container limit, and size memory limits from data.
~6 min readread →
Kubernetes Pod Stuck in Pending: '0/3 nodes are available' Fixed
Fix a Kubernetes Pod stuck in Pending: read the '0/3 nodes are available' event, then fix requests, affinity, taints, PVCs or quotas.
~7 min readread →
Error: Cannot find module in Node.js (MODULE_NOT_FOUND)
Fix Node.js 'Error: Cannot find module' and ERR_MODULE_NOT_FOUND: missing installs, wrong paths, case on Linux, ESM extensions and exports.
~7 min readread →
Error: listen EADDRINUSE: address already in use in Node.js
Fix Node.js 'listen EADDRINUSE: address already in use :::3000': find the process holding the port, close servers on restart, use PORT and port 0.
~9 min readread →
Error: connect ECONNREFUSED 127.0.0.1 in Node.js (and ::1)
Fix Node.js 'Error: connect ECONNREFUSED 127.0.0.1:5432': check the service, localhost vs ::1 since Node 17, Docker networking and startup retries.
~8 min readread →
Node.js 'JavaScript heap out of memory': Reached Heap Limit Fix
Fix Node.js 'Reached heap limit Allocation failed - JavaScript heap out of memory': tell leaks from big data, take heap snapshots, stream.
~8 min readread →
npm error code EACCES: Permission Denied on npm install -g
Fix 'npm error code EACCES permission denied' on global installs without sudo: change the npm prefix, use nvm or fnm, prefer npx, fix Docker.
~8 min readread →
npm error code ERESOLVE: Unable to Resolve Dependency Tree
Fix npm 'code ERESOLVE unable to resolve dependency tree': read the peer conflict report, upgrade the right package, use overrides with care.
~8 min readread →
pip error: externally-managed-environment in Python (PEP 668)
Fix pip's error: externally-managed-environment (PEP 668) on Homebrew, Debian and Ubuntu: use a venv or pipx, not --break-system-packages.
~8 min readread →
IndentationError: expected an indented block in Python
Fix Python IndentationError: expected an indented block, unindent does not match any outer indentation level, and TabError from mixed tabs.
~7 min readread →
KeyError in Python: Fix Missing Dictionary Keys Safely
Fix Python KeyError: 'x': d[key] vs .get, in checks, setdefault and defaultdict, JSON payload validation, pandas columns and odd key reprs.
~7 min readread →
ModuleNotFoundError: No module named 'x' in Python
Fix ModuleNotFoundError: No module named 'x': installs into the wrong interpreter, inactive venvs, pip vs import names and python -m.
~8 min readread →
TypeError: 'NoneType' object is not subscriptable in Python
Fix TypeError: 'NoneType' object is not subscriptable: missing returns, list.sort(), failed re.match, dict.get and Optional type checks.
~7 min readread →
UnboundLocalError: cannot access local variable in Python
Fix UnboundLocalError: cannot access local variable (once 'referenced before assignment'): why assignment makes a name local, global, nonlocal.
~7 min readread →
React: Cannot Update a Component While Rendering a Different One
Fix the React warning 'Cannot update a component while rendering a different component': a child sets parent state during render.
~8 min readread →
React Invalid Hook Call: Hooks Can Only Be Called Inside a Component
Fix 'Invalid hook call' in React: hooks in class components, callbacks or plain functions, duplicate React copies and mismatched react-dom.
~7 min readread →
Maximum Update Depth Exceeded in React: Causes and Fixes
Fix 'Maximum update depth exceeded' in React: effects with no or unstable dependencies, setState in componentDidUpdate and ref callbacks.
~7 min readread →
Objects Are Not Valid as a React Child: Causes and Fixes in React
Fix 'Objects are not valid as a React child' in React: rendering objects, Dates, Errors or props, plus async components on the client.
~7 min readread →
React State Not Updating Immediately After setState: How to Fix
Why React state isn't updated immediately after setState: render snapshots, batching, functional updaters, mutation and when to use useEffect.
~8 min readread →
Too Many Re-renders. React Limits the Number of Renders: How to Fix
Fix 'Too many re-renders' in React: a state setter runs during render, often onClick={setX(1)} or state synced in the component body.
~8 min readread →
Spring @Autowired Field Is Null: Why Injection Didn't Happen
Why is an @Autowired or @Value field null in Spring Boot? Objects built with new, static fields and constructor timing, and how to fix them.
~8 min readread →
Spring Boot Circular Dependency: 'Beans Form a Cycle' Fix
Fix 'the dependencies of some of the beans in the application context form a cycle' in Spring Boot 3 by redesigning beans, not flags.
~8 min readread →
Configuring CORS in Spring Boot: Fixing 'Blocked by CORS Policy'
Fix 'blocked by CORS policy' for a Spring Boot 3 API: global CORS config, Spring Security preflight handling, credentials and exposed headers.
~8 min readread →
Spring Boot: Failed to Configure a DataSource ('url' Not Specified)
Fix 'Failed to configure a DataSource: url attribute is not specified' in Spring Boot 3 by setting the URL, adding the driver or a profile.
~7 min readread →
Jackson Infinite Recursion with JPA Entities in Spring Boot
Fix 'Could not write JSON: Infinite recursion (StackOverflowError)' for bidirectional JPA entities in Spring Boot 3 with DTOs or annotations.
~7 min readread →
Spring Boot: No Qualifying Bean of Type (Could Not Be Found)
Fix 'required a bean of type that could not be found' and 'No qualifying bean' in Spring Boot 3: scanning, conditions, qualifiers, tests.
~7 min readread →
Web Server Failed to Start: Port 8080 Was Already in Use
Fix 'Web server failed to start. Port 8080 was already in use' in Spring Boot: find the process on the port, stop it or change server.port.
~6 min readread →
Whitelabel Error Page 404 in Spring Boot: How to Fix It
Seeing the Whitelabel Error Page with status 404 in Spring Boot 3? Check the mapping, component scan, @RestController and context path.
~7 min readread →
Duplicate Key Value Violates Unique Constraint in PostgreSQL
Fix PostgreSQL 'duplicate key value violates unique constraint': resync sequences after imports, use ON CONFLICT and remove check-then-insert races.
~8 min readread →
Column Must Appear in the GROUP BY Clause in PostgreSQL
Fix PostgreSQL 'column must appear in the GROUP BY clause or be used in an aggregate function' by choosing the grain, aggregates or DISTINCT ON.
~8 min readread →
PostgreSQL 'operator does not exist': Fixing Type Mismatches
Fix PostgreSQL 'operator does not exist: integer = text': read the operand types, cast the constant or parameter, and fix the column type at the source.
~6 min readread →
PostgreSQL 'relation does not exist': Cause and Fix
Fix PostgreSQL 'relation does not exist': check the search_path, qualify the schema, confirm migrations ran here, and fix quoted, case-sensitive identifiers.
~6 min readread →
PostgreSQL 'sorry, too many clients already': Cause and Fix
Fix PostgreSQL 'FATAL: sorry, too many clients already': count connections per app instance, find leaks and idle transactions, and pool safely.
~7 min readread →
TypeScript TS2345: Not Assignable to Parameter of Type 'never'
Fix TS2345 'Argument of type string is not assignable to parameter of type never' from empty arrays, function unions and exhaustive checks.
~7 min readread →
TS2307: Cannot Find Module or Its Type Declarations in TypeScript
Fix TS2307 'Cannot find module or its corresponding type declarations' and TS7016 by tracing module resolution, @types, paths and exports.
~7 min readread →
TypeScript Const Type Parameters
Infer narrow literal and readonly types at call sites with const type parameters, and know the inference it does not change.
~3 min readread →
TypeScript Declaration Merging and Module Augmentation
Merge interfaces and namespaces, augment existing modules and globals safely, and avoid the conflicts that type aliases cannot resolve.
~3 min readread →
TS7053: Element Implicitly Has an 'any' Type in TypeScript
Fix TS7053 'Element implicitly has an any type because expression of type string can't be used to index type' with keyof, Record and guards.
~7 min readread →
TypeScript Excess Property Checks
Why object literals reject extra properties while variables are accepted, and how to control the freshness check deliberately.
~3 min readread →
TypeScript Function Overloads and Resolution
Model multiple call shapes with overload signatures, order them correctly, and know when a union return type is the clearer choice.
~3 min readread →
TS2532: Object Is Possibly 'undefined' (and TS18048) in TypeScript
Fix TS2532 'Object is possibly undefined' and TS18048 by finding where undefined enters the type, then narrowing or failing early.
~8 min readread →
TS2339: Property 'x' Does Not Exist on Type 'Y' in TypeScript
Fix TS2339 'Property does not exist on type' for unions, empty objects, DOM elements and window globals without casting to any.
~7 min readread →
TS2322: Type 'X' Is Not Assignable to Type 'Y' in TypeScript
Fix TS2322 'Type X is not assignable to type Y' by reading the elaboration chain from the bottom and correcting the value, not casting.
~7 min readread →
TypeScript Type Predicates and Assertion Functions
Narrow unknown values with user-defined type guards and assertion functions, and understand the trust they place in your runtime checks.
~3 min readread →
Angular HTTP Request Contract Tests
Use Angular HTTP testing to verify request URLs, methods, response mapping and failures without arbitrary delays.
~3 min readread →
JavaScript Single-Flight Requests
Combine identical in-flight requests with a Map and promises. Trace cleanup, failures and cancellation ownership.
~3 min readread →
Node.js Events and Listener Ordering
Trace synchronous EventEmitter delivery, promise-based waiting and cleanup. Prevent missed events by registering listeners first.
~3 min readread →
Python Bounded Async Worker Queues
Use asyncio.Queue and a fixed worker pool to bound pending work. Trace backpressure, shutdown and failure ownership.
~3 min readread →
React Deferred Results and Stale UI
Build a search interface with urgent input and deferred results. Explain stale feedback, memo boundaries and network limits.
~3 min readread →
PostgreSQL Concurrent Job Claiming
Claim queued jobs with row locks and SKIP LOCKED. Explain transaction boundaries, leases, retries and duplicate effects.
~2 min readread →
Angular Async Validators and Pending State
A username-availability check traced step by step: PENDING status, cancelled checks, debouncing, errors that hang the form, and safe submit.
~6 min readread →
Angular Component Tests That Verify Behavior
Test an Angular component through its DOM, inputs, outputs and HTTP calls, so refactors pass and real bugs fail. Five tests, run and broken.
~6 min readread →
Angular Content Projection and Ownership
Why projected content is created by the parent even inside a closed @if, how select slots match, and when ng-template makes projection lazy.
~6 min readread →
Angular Custom Controls and Value Accessors
A star-rating ControlValueAccessor, built and then broken: what writeValue, onChange, onTouched and setDisabledState each must do.
~5 min readread →
Angular Hierarchical Providers and Service Lifetimes
Where a service is provided decides who shares it: providedIn root, component providers, viewProviders and route providers, with instance ids.
~6 min readread →
Angular HTTP Error Handling: catchError and Safe Retries
Handle Angular HttpClient failures without stopping a search stream. Learn where catchError belongs, when retries are safe and how to test recovery.
~4 min readread →
Angular HTTP Interceptors and Request Immutability
Functional interceptors in Angular 19 and 20: why headers.set() silently does nothing, how clone() works, chain order, retries, and token leaks.
~6 min readread →
Angular Inject and Injection Contexts
Where inject() works and where it throws NG0203: constructors, field initializers and guards versus ngOnInit, timers and code after await.
~6 min readread →
Angular Lazy Routes and Feature Boundaries
How one innocent import moved a lazy feature into the initial bundle (233 kB to 407 kB), and how to draw boundaries that keep lazy routes lazy.
~6 min readread →
Angular OnPush and Input Reference Changes
Why an OnPush child ignores user.role = 'admin' but updates for a new object, what else marks it dirty, and how signal inputs change the picture.
~6 min readread →
Angular Reactive Forms and State Ownership
Who owns the edit state in an Angular reactive form: loading server data with patchValue, splitting subforms, avoiding echo loops and lost edits.
~6 min readread →
Angular Cross-Field Validation with Reactive Forms
Build an Angular password-confirmation validator, show accessible errors and test matching, mismatching, empty and reset states in reactive forms.
~3 min readread →
Angular Route Guards and Server Authorization
Route guards decide what the Angular router shows, not what a user may do. Why the admin chunk is still public and where the real check belongs.
~6 min readread →
Angular Route Parameters and Reused Components
Going from /products/1 to /products/2 reuses the component, so snapshot reads go stale. Read params with paramMap, toSignal or input binding.
~6 min readread →
Angular Resolvers and Navigation Data
What a ResolveFn really does to navigation: the delay, reruns on param change, RedirectCommand for 404s, and why EMPTY or an error cancels it.
~6 min readread →
Angular RxJS Mapping Operators and Intent
switchMap, mergeMap, concatMap or exhaustMap? One timeline of four requests shows what each operator does, and which fits search, save and login.
~6 min readread →
Angular Computed Signals and Derived Values
Why a cart total belongs in computed() and not a second signal, how Angular tracks dependencies lazily, and when linkedSignal fits.
~7 min readread →
Angular Effects and External Synchronization
What effect() is actually for in Angular: pushing signal state to localStorage, the DOM or a chart library, with cleanup, untracked and timing.
~6 min readread →
Angular Signals and Immutable Collection Updates
Why push() on a signal's array leaves the screen stale, what Object.is equality means for update(), and how to edit nested lists without bugs.
~6 min readread →
Angular Standalone Components and Template Imports
How a standalone component's imports array works, the NG8001, NG8002 and NG8004 errors it prevents, and the directive that fails silently.
~5 min readread →
Angular Subscription Cleanup and Component Lifetime
Which Angular subscriptions leak and which end on their own, measured with a live Subject, plus takeUntilDestroyed, toSignal and the async pipe.
~6 min readread →
Angular View Queries and Lifecycle Timing
When viewChild() and @ViewChild actually hold a value: constructor, ngOnInit, ngAfterViewInit and @if blocks, measured in compiled Angular 20.
~6 min readread →
AWS API Gateway and Application Error Contracts
Why API Gateway errors and your Lambda errors look different to clients, and how to give every failure one status, shape and request ID.
~7 min readread →
AWS Auto Scaling and Dependency Limits
How EC2 Auto Scaling reacts to load, why scaling on the wrong metric backfires, and how to cap a fleet at what its databases and APIs can take.
~7 min readread →
AWS CloudWatch Metrics, Logs and Alarm Meaning
How CloudWatch statistics, periods and M-of-N alarms decide when you get paged, what missing data does, and which signals deserve a page.
~7 min readread →
AWS Cost Visibility and Bounded Experiments
Seeing where AWS money goes with tags and Cost Explorer, why budgets alert but don't stop spend, and how to fence experiments with SCPs.
~7 min readread →
AWS DynamoDB Keys and Access Patterns
How to design DynamoDB partition and sort keys from your queries: listing access patterns first, composite sort keys, GSIs and hot partitions.
~6 min readread →
AWS DynamoDB Conditional Writes and Concurrency
How DynamoDB condition expressions stop lost updates: create-only puts, version checks, atomic counters with guards, and transactions.
~6 min readread →
AWS IAM Policies and Permission Decisions
How IAM decides allow or deny: explicit denies, SCPs, permissions boundaries, resource policies, and how to debug an AccessDenied error.
~6 min readread →
AWS Lambda Invocation and Execution Lifetimes
What happens inside a Lambda execution environment from init to shutdown, what survives between calls, and how timeouts and concurrency add up.
~6 min readread →
AWS Lambda Retries and Idempotent Handlers
Who retries a failed Lambda invocation (the caller, the async queue or the event source) and how to write handlers that survive running twice.
~7 min readread →
AWS NAT Gateways and Private Outbound Access
How a NAT gateway gives private subnets outbound internet access, why you want one per Availability Zone, and where its data charges come from.
~6 min readread →
AWS RDS Connections and Database Capacity
Why RDS runs out of connections long before it runs out of CPU, how to size pools from query rate and latency, and when RDS Proxy actually helps.
~7 min readread →
AWS Roles and Temporary Credentials
What an IAM role is, how AssumeRole hands out short-lived keys, how EC2, Lambda and ECS get them automatically, and why that beats access keys.
~6 min readread →
AWS S3 Objects, Access and Application Semantics
What S3 guarantees after a write, why concurrent writers still overwrite each other, and how bucket policies and presigned URLs grant access.
~7 min readread →
AWS S3 Versioning and Recovery Limits
How S3 versioning keeps old copies and delete markers, how to restore an overwritten or deleted file, and what versioning can't protect against.
~7 min readread →
AWS Security Groups Versus Network ACLs
Security groups are stateful and sit on interfaces; network ACLs are stateless, ordered and sit on subnets. What that means for reply traffic.
~7 min readread →
AWS Shared Responsibility and Service Boundaries
What AWS secures and what you secure, how the line moves across EC2, RDS, Lambda and S3, and who owns the fix when something goes wrong.
~6 min readread →
AWS SNS Fanout and Subscriber Independence
How SNS fans one event out to many subscribers, why each subscription succeeds or fails alone, and when to put an SQS queue behind each one.
~7 min readread →
AWS SQS Delivery and Visibility Timeouts
Why SQS delivers messages more than once, how the visibility timeout and receipt handles work, and how to process slow jobs without duplicates.
~7 min readread →
AWS VPC Routes and Network Reachability
How VPC route tables pick a target by longest prefix, what makes a subnet public or private, and how to debug an instance that can't connect.
~6 min readread →
AWS Architecture Trade-Offs and Failure Assumptions
Reasoning about AWS design trade-offs: which failures you plan for, how availability multiplies across dependencies, and what DR tiers cost.
~7 min readread →
Behavioral Interviews: Working With Ambiguous Requirements
Show how you handled unclear requirements: naming what's unknown, ranking assumptions by the cost of being wrong, and finding who decides.
~6 min readread →
Behavioral Interviews: Explaining a Career Transition
Explain a career change so it sounds deliberate: a bridge from your old work, recent evidence in the new field and an honest view of the gaps.
~7 min readread →
Behavioral Interviews: Resolving Technical Disagreement
Tell a technical disagreement story with no villain: agree on criteria, test both options, reach a decision, and commit to it even if you lost.
~6 min readread →
Behavioral Interviews: Customer Impact and Evidence
Tell a customer-impact story built on evidence: what users actually hit, the change you made, and results you can show without inventing numbers.
~6 min readread →
Behavioral Interviews: Handling an Unrealistic Deadline
Tell an unrealistic-deadline story well: break down the estimate, bring options on scope and date, let the date's owner choose, then track it.
~7 min readread →
Behavioral Interviews: Responding to Uncomfortable Pressure
Answer integrity questions with judgment: raise the concern early, offer an honest alternative, escalate in proportion and keep confidences.
~7 min readread →
Behavioral Interviews: Failure and Specific Learning
Answer 'tell me about a time you failed' with a real mistake, what you did to recover, and a change in your habits that someone could observe.
~6 min readread →
Behavioral Interviews: Receiving Difficult Feedback
Show how you handled critical feedback: hearing it out, asking for examples, deciding what was accurate, changing something and checking back.
~6 min readread →
Behavioral Interviews: Communicating During an Incident
Tell an incident story that shows how you communicated: clear roles, updates that separate facts from guesses, and not saying fixed too early.
~7 min readread →
Behavioral Interviews: Leading Without Formal Authority
Show leadership without a title: spotting work nobody owned, making responsibilities visible, coordinating people and crediting the team.
~6 min readread →
Behavioral Interviews: Mentoring and Knowledge Transfer
Show mentoring that builds independence: teaching a method instead of fixing the bug, adapting to the person, and evidence that they learned it.
~6 min readread →
Reviewing a Mock Behavioral Interview
Review a mock behavioral interview the way a scorer would: record it, rate each answer on a rubric, fix the patterns and rehearse follow-ups.
~7 min readread →
Behavioral Interviews: Prioritizing Competing Work
Explain how you chose between competing work: criteria like impact and cost of delay, a real trade-off, and telling people what moved and why.
~7 min readread →
Explaining Project Ownership in an Interview
Explain a project you owned without overclaiming: the decisions that were yours, the work others did, and what you looked after once it shipped.
~6 min readread →
Behavioral Interviews: Balancing Quality and Delivery
Show which quality you protected and which you deferred under a deadline, how you wrote the shortcut down, and the plan to come back to it.
~6 min readread →
Questions to Ask About a Role and Team
Make 'Do you have any questions?' count: ask what would change your decision, request examples over opinions and follow up on the answers.
~6 min readread →
Interview Introductions With Relevant Evidence
Answer 'tell me about yourself' in about ninety seconds: your current focus, one piece of work matched to the job ad, and why this role.
~7 min readread →
Behavioral Interviews: Explaining Technical Trade-Offs
Explain a technical trade-off to non-engineers in an interview story: consequences instead of jargon, honest ranges, and who decides.
~7 min readread →
Behavioral Interviews: A Clear STAR Story
Turn a real project into a two-minute STAR answer: how long each part runs, a weak and a strong telling of one story, and the follow-ups.
~7 min readread →
Behavioral Interviews: A Useful Weakness Answer
Pick a real weakness that won't sink you, show what you changed and the evidence it's working, and handle 'What would your manager say?'
~6 min readread →
Docker Multi-Platform Images and Native Dependencies
How one tag serves amd64 and arm64, why native modules break across CPUs, and how to build multi-platform images by emulating or cross-compiling.
~5 min readread →
Docker Bind Mounts and Host Coupling
Bind mounts map a host path into a container: great for live code, risky for ownership, portability and security. See where each one bites.
~6 min readread →
Docker Compose Dependencies and Readiness
Plain depends_on only orders container starts. Use healthchecks, service_healthy and service_completed_successfully to wait for a ready database.
~5 min readread →
Docker Entrypoint and Command Overrides
How ENTRYPOINT and CMD combine into one argv, what docker run arguments replace, and why appending sh to some images never gives you a shell.
~6 min readread →
Docker Health Checks and Useful Probes
How a HEALTHCHECK moves from starting to unhealthy, why plain Docker never restarts an unhealthy container, and what a good probe checks.
~5 min readread →
Docker Build Context and Ignore Rules
What the build context is, why COPY . . can ship your .env and .git, and how to write .dockerignore patterns that match nested folders.
~5 min readread →
Docker Images Versus Running Containers
An image is a read-only template; a container is that template plus a writable layer and a process. See what survives stop, start and rm.
~5 min readread →
Docker Base Image Maintenance and Dependency Updates
An image is frozen the day it's built. Keep bases patched with scheduled rebuilds, --pull, digest pins with automated bumps and EOL tracking.
~6 min readread →
Docker Image Tags and Reproducible Releases
Tags are movable pointers and digests are not. Learn why latest breaks rollbacks, how to tag releases, and when to pin images by sha256.
~5 min readread →
Docker Layers and Build Cache Invalidation
Why one edited source file can rerun npm install: how BuildKit's layer cache keys each step, and how to order a Dockerfile so rebuilds stay fast.
~5 min readread →
Docker Logs and Application Diagnostics
docker logs only shows stdout and stderr. Fix empty logs, Python buffering and unrotated json-file growth, then pick a logging driver.
~5 min readread →
Docker Multi-Stage Builds and Runtime Contents
Compile in one stage, ship only the output in the next: how a 400 MB build image became a 313 kB runtime, and what a scratch image gives up.
~5 min readread →
Docker Networks and Container DNS
Why containers can't resolve each other on the default bridge, how the 127.0.0.11 resolver works, and why nginx keeps a stale upstream IP.
~5 min readread →
Docker Nonroot Users and File Permissions
Switching a container to a nonroot USER breaks writes until ownership is right. Fix EACCES with chown, numeric UIDs and pre-created volume paths.
~5 min readread →
Docker Exposed Ports Versus Published Ports
EXPOSE documents a port; -p opens one on the host. Bind addresses, -P, the 127.0.0.1 trap inside containers and the ufw bypass on Linux.
~5 min readread →
Docker Read-Only Filesystems and Writable Paths
Run a container with --read-only, find the paths it still needs to write, and give each one a sized tmpfs or volume without reopening the rest.
~5 min readread →
Docker Resource Limits and Application Capacity
Memory limits end in a silent OOM kill and CPU limits in throttling. Size a container so the runtime inside it agrees with the cgroup outside.
~6 min readread →
Docker Secrets and Image Layer History
Build args and ENV values stay readable in docker history and image config. Pass build-time credentials with BuildKit secret mounts instead.
~5 min readread →
Docker Process Signals and Graceful Shutdown
Why docker stop sometimes takes the full timeout and ends in exit 137, and how PID 1, exec form and a SIGTERM handler fix shutdown.
~6 min readread →
Docker Volumes and Data Lifetimes
Named and anonymous volumes outlive containers in different ways. Trace which commands keep data, which delete it, and how to back it up.
~5 min readread →
Backtracking and Safe Pruning Rules
Backtracking as choose, explore, unchoose, and the proof each prune needs: sorted breaks, duplicate skips and the negative-number trap.
~7 min readread →
Big-O Complexity and Input Growth
Read Big-O as a growth rate: count steps as n doubles, name separate inputs n and m, and spot the hidden O(n) inside one-line operations.
~6 min readread →
Binary Search on an Answer Space
Binary search a numeric answer instead of an array: monotonic feasibility checks, tight bounds and min-max versus max-min variants.
~6 min readread →
Binary Search and Explicit Boundaries
Write binary search from an invariant: half-open [lo, hi), lower_bound traced step by step, and the loop and overflow bugs it prevents.
~7 min readread →
Dynamic Programming and State Definition
Define the DP state as one sentence before any table: House Robber from 4.3 million calls to 32, coin loop order and an LCS walkthrough.
~7 min readread →
Graph DFS States and Cycle Detection
Why directed cycle detection needs three DFS states, how to return the actual cycle, and an iterative version that avoids RecursionError.
~6 min readread →
Hash Maps for Frequency and Membership Problems
Use hash maps to count and look up in O(1): Two Sum's lookup order, anagram keys, the JavaScript constructor trap and consecutive runs.
~6 min readread →
Heaps for Top-K and Incremental Selection
Keep the k largest items with a size-k min-heap: a traced stream, timings against sorting, heapq tie-breaking and K Closest Points.
~7 min readread →
Linked List Cycles and Fast-Slow Pointers
Floyd's tortoise and hare in O(1) space: why fast meets slow, the null check order, finding the cycle's entry and the duplicate-number twist.
~7 min readread →
Linked List Reversal and Pointer Ownership
Reverse a linked list by tracking who keeps each node reachable: a traced JavaScript loop, the lost-tail bug, sublists and palindrome checks.
~6 min readread →
Monotonic Stacks and Nearest Greater Elements
Find the next warmer day, next greater element or widest rectangle in O(n) with a monotonic stack, traced on Daily Temperatures.
~7 min readread →
Prefix Sums for Repeated Range Queries
Answer range-sum queries in O(1) after an O(n) pass: the prefix[0] = 0 convention, counting subarrays that sum to k, 2D grids and products.
~6 min readread →
Breadth-First Search and Unweighted Shortest Paths
Why BFS finds shortest paths when every edge costs the same: a maze solved with parent pointers, mark-on-enqueue and multi-source BFS.
~7 min readread →
Sliding Windows and Validity Invariants
Solve contiguous subarray and substring problems in O(n): state what makes a window valid, then expand right and shrink left to keep it so.
~6 min readread →
Algorithm Space Complexity and Auxiliary Storage
Count the memory an algorithm adds: input vs output vs auxiliary, recursion depth as space, hidden slice copies, all measured with tracemalloc.
~6 min readread →
Stacks for Balanced Delimiters and Nested Structure
Use a stack wherever the last thing opened must close first: bracket checks with error positions, RPN division and decoding nested strings.
~6 min readread →
Topological Sorting and Dependency Order
Order build steps or courses so dependencies run first: Kahn's algorithm traced, cycle reporting, isolated nodes and the minimum-semesters twist.
~6 min readread →
Tree Traversals and Information Flow
Pick preorder, inorder or postorder by asking which way information flows: bounds passed down, heights returned up, sorted order from BSTs.
~7 min readread →
Two Pointers and Monotonic Search Decisions
Two pointers work when each move rules out answers you can prove are worse: sorted pair sums, Container With Most Water, 3Sum and palindromes.
~7 min readread →
Union-Find for Connectivity and Components
Track merging groups with union-find: parent pointers, union by size and path compression measured, cycle detection and Number of Islands.
~7 min readread →
Git Bisect and Reproducible Regression Checks
Find the commit that broke a test with git bisect run, why unbuildable commits need exit 125, and how flaky checks blame the wrong commit.
~6 min readread →
Git Branching Strategies and Integration Frequency
GitFlow, GitHub Flow and trunk-based development compared by what matters: how long code waits before it meets everyone else's changes.
~6 min readread →
CI Build Once and Promote the Same Artifact
Rebuilding for each environment means production runs bytes nobody tested. Promote one artifact by digest and inject config at deploy time.
~6 min readread →
CI Canary Releases and Decision Metrics
A canary is only as good as its pass/fail rule. Pick metrics, compare against a live baseline and wait for enough traffic before you promote.
~6 min readread →
Git Cherry-Pick and Patch-Based Backports
Backport a fix to a release branch with git cherry-pick -x, handle the conflict when it depends on an earlier commit, and spot duplicate patches.
~6 min readread →
CI Required Checks and Meaningful Validation
A green required check can hide a failed test. How pipes, skipped jobs and path filters fool branch protection, and how one gate job fixes it.
~6 min readread →
Git Atomic Commits and Reviewable Changes
An atomic commit does one thing and still builds. Split mixed edits with git add -p, fold follow-up fixes in with --fixup, and revert precisely.
~6 min readread →
Git Conflict Resolution and Combined Intent
Resolve a Git merge conflict by working out what each side meant. Read the base with zdiff3, avoid the keep-both trap and test the combined rule.
~6 min readread →
CI Feature Flags and Lifecycle Ownership
Feature flags let you merge unfinished work and roll out slowly. Bucket users deterministically, give each flag an owner and expire it in CI.
~7 min readread →
Git Ignore Rules and Already Tracked Files
A tracked file stays tracked after you add it to .gitignore. Untrack it with git rm --cached and warn teammates, whose pull deletes it.
~6 min readread →
CI Merge Queues and Combined Change Validation
Two pull requests can each pass CI and still break main together. A merge queue tests each one on top of everything queued ahead of it.
~6 min readread →
Git Merge Versus Rebase and Shared History
Merge joins histories; rebase rewrites your commits onto a new base. When to use each, and how a background fetch defeats --force-with-lease.
~6 min readread →
CI Caches Versus Reproducible Build Inputs
A CI cache should make builds faster, never different. Key it on every input, cache ~/.npm rather than node_modules, and use restore-keys warily.
~6 min readread →
Git Reflog and Recovering Lost References
Undo a bad reset --hard, restore a deleted branch or a dropped stash with git reflog and git fsck, and learn which lost work Git can't recover.
~6 min readread →
CI Release Versions and Artifact Traceability
Derive release versions from annotated Git tags, stamp them into every artifact, and fix the shallow-clone CI failure that breaks git describe.
~6 min readread →
Git Revert Versus Reset for Undoing Changes
Reset moves a branch back; revert adds a commit that undoes one. Which is safe when, and the merge-revert trap that drops work on re-merge.
~6 min readread →
CI Rollbacks and Data Compatibility
Rolling back code is easy; rolling back data isn't. Why a column rename breaks the last release, and how expand and contract keeps rollback safe.
~6 min readread →
CI Secrets and Untrusted Contributions
Fork pull requests run code you didn't write. How GitHub Actions withholds secrets, and how pull_request_target and script injection leak them.
~6 min readread →
Git Stash and Temporary Work Ownership
git stash is fine for five minutes and risky for five days: what it skips, why pop can leave a mess, and when a branch or worktree is better.
~6 min readread →
Git Working Tree, Index and Commit Snapshots
Git keeps three copies of each file: working tree, index and HEAD. Why a staged file can still show as modified, and what a commit really stores.
~6 min readread →
HTML Data Tables and Header Relationships
How th, scope, caption and headers/id tell a screen reader which headers describe a cell, with a two-level pricing table worked through.
~7 min readread →
HTML Buttons Versus Links for Actions
Links go somewhere and buttons do something. What each element gives you for free, and what breaks when a div or an a tag fakes the other.
~6 min readread →
CSS Container Queries for Reusable Components
Build a card that switches layout based on the space it's given, not the viewport: container-type, named containers, cqi units and the gotchas.
~6 min readread →
CSS Box Sizing and Predictable Dimensions
Why width: 300px can render 342px wide, how border-box changes the arithmetic, and the global reset most projects start with, with numbers.
~5 min readread →
CSS Custom Properties and Theme Boundaries
How CSS variables inherit, when var() resolves, why bad values fail silently, and how to scope theme tokens so components can override them.
~5 min readread →
CSS Flex Items and Unexpected Overflow
Why a flex item holding a long URL or code block won't shrink, what min-width: auto computes, and when min-width: 0 or minmax(0, 1fr) fixes it.
~6 min readread →
CSS Focus Visibility and Keyboard Navigation
Why outline: none strands keyboard users, how :focus-visible decides when to show a ring, and focus styles that hold up on any background.
~6 min readread →
HTML Form Labels and Accessible Names
How label, for/id, aria-labelledby and aria-describedby give each field a name and a hint, and why placeholder text can't stand in for a label.
~6 min readread →
CSS Grid Tracks and Minmax Sizing
How fr shares free space, what minmax() and auto mean for a track, and the math behind repeat(auto-fill, minmax(220px, 1fr)) at real widths.
~5 min readread →
HTML Headings and Document Navigation
How screen reader users jump between headings, why levels should follow structure rather than font size, and how to fix skipped levels.
~6 min readread →
HTML Alt Text Based on Image Purpose
Writing alt text by asking what the image does on the page: informative, functional, decorative or complex, with real before-and-after examples.
~6 min readread →
HTML Image Loading and Page Priorities
When loading="lazy" helps and when it delays your LCP image, how fetchpriority and preload change the queue, and why width and height matter.
~6 min readread →
CSS Logical Properties for Direction-Aware Layout
Swap left and right for inline-start and inline-end so one stylesheet serves English, Arabic and vertical text, with a card converted.
~6 min readread →
CSS Positioning and Containing Blocks
What top: 0 is measured from for each position value, how ancestors become containing blocks, and why transform breaks position: fixed.
~6 min readread →
HTML Progressive Enhancement and Reliable Navigation
A product filter built as a plain GET form first, then enhanced with fetch and pushState without breaking shared links or the back button.
~6 min readread →
CSS Reduced Motion and Meaningful Alternatives
What prefers-reduced-motion signals, which animations to remove or replace, and how to keep state changes clear when the motion is gone.
~5 min readread →
HTML Responsive Images and Source Selection
How browsers pick a file from srcset using sizes and pixel density, when to use picture, and the math for a phone, a tablet and a laptop.
~6 min readread →
CSS Responsive Units and Content Constraints
When to use px, rem, em, %, ch, vw and dvh, how clamp() builds fluid type that still zooms, and why 100vh breaks on phones, with real numbers.
~6 min readread →
HTML Landmarks and Meaningful Page Structure
How header, nav, main, aside, footer and labelled sections become landmarks that screen reader users jump between, with a div-soup page rebuilt.
~6 min readread →
CSS Z-Index and Stacking Contexts
Why z-index: 9999 can still sit under a z-index: 10 header, which properties create stacking contexts, and how to debug and fix layering bugs.
~6 min readread →
Java ArrayList Capacity and Performance
How ArrayList grows its backing array by 1.5x, why add is amortized O(1), and when ensureCapacity or a different list actually helps.
~8 min readread →
Java Comparators and Ordered Collections
Why TreeSet and TreeMap drop elements when a Comparator disagrees with equals, and how to write comparators that obey the full contract.
~6 min readread →
Java CompletableFuture Error Composition
How exceptions travel through CompletableFuture chains, when to use exceptionally, handle or whenComplete, and why causes arrive wrapped.
~7 min readread →
Java Concurrent Collections and Compound Operations
Why check-then-act on ConcurrentHashMap still races, and how merge, compute and putIfAbsent make compound updates atomic per key.
~7 min readread →
Java Equals and HashCode Collection Contracts
The equals and hashCode contract explained: why equal objects need equal hash codes, how HashMap uses both, and how to write a correct pair.
~6 min readread →
Java Exceptions and Recovery Boundaries
Checked vs unchecked exceptions in Java, where to catch, when to wrap with a cause, and how to avoid swallowing failures at the wrong layer.
~6 min readread →
Java Executors and Task Lifecycle
How shutdown, shutdownNow and awaitTermination differ in ExecutorService, and the safe pattern for stopping thread pools without losing work.
~6 min readread →
Java Garbage Collection and Retained Objects
How Java memory leaks happen despite garbage collection: GC roots, reachability, retained size, and finding the reference chain in a heap dump.
~7 min readread →
Java HashMap Collisions and Key Quality
How HashMap works internally: hash spreading, bucket index, collisions, load factor resizing and the Java 8 switch from chains to trees.
~7 min readread →
Java Immutable Objects and Defensive Copies
How to make a class immutable in Java: final fields, no setters, defensive copies of mutable inputs and outputs, and safe publication.
~6 min readread →
Java Time Types and Zone-Aware Decisions
When to use Instant, LocalDateTime, ZonedDateTime and OffsetDateTime, and how daylight saving gaps and overlaps break naive date code.
~6 min readread →
Java Optional as an Absence Contract
When to return Optional in Java, why get and isPresent checks miss the point, and why Optional fields, parameters and collections are a smell.
~6 min readread →
Java Records and Shallow Immutability
What Java records generate, why they are only shallowly immutable, how compact constructors copy and validate, and where records do not fit.
~6 min readread →
Java Streams and Lazy Pipelines
Why Java stream intermediate operations do nothing until a terminal operation runs, how elements flow one by one, and where laziness bites.
~6 min readread →
Java Stream Reuse and Collection Ownership
Why reusing a Java stream throws IllegalStateException, how to share data with a Supplier or a collection, and what toList returns.
~6 min readread →
Java String Equality and Identity
Java String equals vs ==: why == compares references, how the string pool and compile-time constants make it seem to work, and safe comparisons.
~6 min readread →
Java Synchronized Blocks and Shared Invariants
What synchronized guarantees in Java: mutual exclusion, visibility and reentrancy, plus how to guard multi-field invariants with one lock.
~7 min readread →
Java Thread Visibility and Happens-Before
Why one Java thread may never see another's write, what volatile guarantees, and how happens-before rules make publication safe.
~7 min readread →
Java Try-With-Resources and Cleanup
How try-with-resources closes resources in reverse order, keeps the primary exception with suppressed close failures, and beats finally.
~6 min readread →
Java Virtual Threads and Blocking Workloads
When Java 21 virtual threads help, why they do not speed up CPU-bound work, and how pinning, pooling and resource limits trip teams up.
~7 min readread →
JavaScript Abort Signals and Request Ownership
Learn AbortController step by step: cancel fetch, prevent stale search results, combine cancellation with timeouts and handle errors correctly.
~9 min readread →
JavaScript Array Copies and Shared Objects
Why a spread or slice copy of a JavaScript array still shares its nested objects, and how to pick shallow, structured or targeted copies.
~2 min readread →
JavaScript reduce(): Initial Value, Accumulator and Mutation
How Array.prototype.reduce works, why the initial value matters for empty arrays, and when mutating the accumulator is safe or quadratic.
~8 min readread →
Async/Await in Loops: forEach vs for...of vs Promise.all
Why await inside forEach does not wait, how for...of runs tasks in sequence, and how to run async work in parallel with a concurrency limit.
~7 min readread →
JavaScript Equality: Object Identity and Coercion
How === and == really compare JavaScript values: type coercion rules, why two equal-looking objects are not equal, and how to compare contents.
~2 min readread →
JavaScript Event Delegation and Dynamic Elements
One click listener on a parent can serve rows added later. How closest(), contains() and composedPath() keep delegation from misfiring.
~7 min readread →
JavaScript Object.freeze: Shallow vs Deep Freeze and Limits
What Object.freeze really locks, why it is shallow, how strict mode changes failures, and how to deep freeze config without surprises.
~7 min readread →
JavaScript Generators: return(), finally and Cleanup on Early Exit
How break, return and throw end a generator early, why finally blocks run on cleanup, and how to avoid leaking handles in iterators.
~6 min readread →
JavaScript Iterator Protocol: Make Any Object Iterable
How Symbol.iterator, next() and done power for...of and spread, how to make a class iterable, and why iterators are usually single-use.
~6 min readread →
JavaScript Map vs Object: When to Use Each (Interview Answer)
Map vs plain object for lookups: key types, insertion order, size, prototype keys like __proto__, JSON support and performance trade-offs.
~6 min readread →
JavaScript Memory Leaks and Retained References
A forgotten listener kept 200 models and 76 MB alive in Node. How to prove a leak with GC and heap snapshots, then break the retaining path.
~7 min readread →
ES Module Live Bindings vs CommonJS: Interview Guide
Why ES module imports see later changes to exported variables, why CommonJS copies values, and how live bindings affect circular imports.
~7 min readread →
Nullish Coalescing (??) vs OR (||) in JavaScript: Defaults Explained
Why || replaces 0, empty strings and false with defaults while ?? only replaces null and undefined, plus ??=, precedence and parameter defaults.
~6 min readread →
Promise.all vs allSettled vs race vs any: JavaScript Interview Guide
How Promise.all, allSettled, race and any settle, what each does on rejection or empty input, and how to pick the right one for real requests.
~7 min readread →
Promise finally() in JavaScript: Cleanup Without Losing Errors
How promise finally() passes results and errors through, when a finally callback overrides the outcome, and how try/finally compares.
~7 min readread →
JavaScript Property Descriptors: writable, enumerable, configurable
How Object.defineProperty and property descriptors control writes, enumeration and deletion, how getters and setters fit in, and their traps.
~6 min readread →
for...in vs Object.keys vs Reflect.ownKeys: Key Order Explained
Which JavaScript APIs list inherited, non-enumerable and symbol keys, and why integer-like keys always come first in object property order.
~6 min readread →
Prototype Pollution in JavaScript: How It Works, How to Prevent It
How __proto__ and constructor.prototype keys in JSON poison every object through unsafe merges, and the defences that close the hole.
~8 min readread →
Remove Duplicates from a JavaScript Array with Set (and Objects)
Why new Set removes duplicate primitives but not duplicate objects, how SameValueZero treats NaN and -0, and how to dedupe objects by key.
~6 min readread →
WeakMap vs Map in JavaScript: Garbage Collection and Leaks
Why WeakMap keys do not keep objects alive, why WeakMaps cannot be iterated, and how to attach caches and private data without leaking memory.
~8 min readread →
Kubernetes Autoscaling and Meaningful Metrics
Pick the metric your autoscaler follows: CPU versus queue backlog, the HPA replica formula, and capping replicas at what the database can take.
~7 min readread →
Kubernetes ConfigMaps Versus Secrets
ConfigMap or Secret? Why base64 isn't encryption, what actually protects a Secret, and how env vars and mounted files behave on update.
~6 min readread →
Kubernetes CronJobs and Overlapping Runs
What happens when a CronJob run outlasts its schedule: Allow, Forbid and Replace, startingDeadlineSeconds, and why the job must be idempotent.
~6 min readread →
Kubernetes Deployments and Rolling Updates
How a Deployment rolls out a new image: ReplicaSets, maxSurge and maxUnavailable arithmetic, readiness gating, progress deadlines and rollback.
~6 min readread →
Kubernetes Ingress Routing and Controller Ownership
Why an Ingress does nothing without a controller, how ingressClassName picks one, how host and path rules match, and how to read 404 versus 503.
~6 min readread →
Kubernetes Jobs and Repeatable Batch Work
How Kubernetes Jobs retry failed Pods: backoffLimit, restartPolicy, deadlines, podFailurePolicy for exit codes, and making each run safe to repeat.
~6 min readread →
Kubernetes Namespaces and Isolation Limits
What a namespace scopes (names, RBAC, quotas, policies) and what it leaves open: network traffic, nodes, cluster-scoped objects and DNS.
~6 min readread →
Kubernetes Network Policies and Traffic Direction
How NetworkPolicy selects Pods, why ingress and egress are separate, the AND/OR selector trap, and why default-deny egress breaks DNS.
~6 min readread →
Kubernetes Affinity, Taints and Scheduling Intent
When to use nodeSelector, node affinity, pod anti-affinity or taints and tolerations, and why a toleration alone never pins a Pod to a node.
~6 min readread →
Kubernetes Persistent Volumes and Claims
How PVCs bind to PersistentVolumes, why WaitForFirstConsumer matters, what access modes really mean, and how reclaim policy loses data.
~6 min readread →
Kubernetes Disruption Budgets and Maintenance
How PodDisruptionBudgets gate evictions during drains and upgrades, minAvailable vs maxUnavailable maths, and budgets that block drains.
~6 min readread →
Kubernetes Pods and Disposable Workload Instances
What the containers in a Pod share, how phases differ from container states, and why Pods get replaced with new names and IPs.
~6 min readread →
Kubernetes Startup, Readiness and Liveness Probes
What each Kubernetes probe does when it fails, why liveness must not check your database, and how to size a startupProbe for a slow boot.
~6 min readread →
Kubernetes RBAC and Least-Privilege Access
Build a least-privilege Role for a CI deployer, verify it with kubectl auth can-i, and spot grants like pods/exec that quietly escalate.
~6 min readread →
Kubernetes Requests, Limits and Scheduling
How CPU and memory requests drive scheduling, what limits enforce (throttling vs OOMKill), how QoS classes form, and how to choose numbers.
~6 min readread →
Kubernetes Security Contexts and Runtime Permissions
Harden a Pod with runAsNonRoot, dropped capabilities, seccomp and a read-only root filesystem, and decode the errors each setting can produce.
~6 min readread →
Kubernetes Service Selectors and Endpoints
How a Service selector becomes EndpointSlices, why a Service with no endpoints refuses connections, and how to debug label and port mismatches.
~6 min readread →
Kubernetes StatefulSets and Stable Workload Identity
What a StatefulSet guarantees: ordinal names, per-Pod DNS via a headless Service, a claim per replica, ordered rollouts, and what it doesn't.
~6 min readread →
Kubernetes Pod Termination and Connection Draining
The exact order of a Pod shutdown, why endpoint removal races SIGTERM and causes 502s, and how preStop, grace periods and app code fix it.
~7 min readread →
Kubernetes Troubleshooting From Symptoms to Evidence
A repeatable order for debugging Kubernetes: Pod status, events, previous logs, endpoints, then the node, with the command and clue at each step.
~6 min readread →
Microservice API Gateways and Edge Responsibilities
What an API gateway should own (TLS, token checks, routing, rate limits) and why refund rules and workflows belong in the services behind it.
~7 min readread →
Microservice Bulkheads and Resource Partitioning
How a slow recommendations call starves checkout through a shared pool, and how to size separate bulkheads with Little's law and fast rejection.
~6 min readread →
Microservice Circuit Breakers and Failure Isolation
Closed, open and half-open states traced through a runnable breaker, plus sizing, which errors to count and what callers do when it's open.
~6 min readread →
Microservice Configuration and Safe Rollouts
Treat config changes like deploys: validate before applying, roll out by stable user buckets or by instance, and keep a fast rollback.
~7 min readread →
Microservice Consumers and Duplicate Events
Why at-least-once delivery hands a consumer the same event twice, and how a processed-message table in one transaction stops a double credit.
~6 min readread →
Microservice Contract Evolution and Compatibility
Which API and event changes are safe, why a rename breaks even tolerant readers, and how expand-and-contract lets a producer ship alone.
~6 min readread →
Microservice Data Ownership and Shared Databases
Why read-only access to another service's tables still couples you to its schema, and how APIs, events and local copies replace sharing.
~6 min readread →
Microservice Deadlines Across Call Chains
Why per-hop timeouts keep services working after the client has left, and how passing a remaining-time budget down the chain stops it.
~6 min readread →
Microservice Tracing and Request Causality
How trace and span ids travel in the W3C traceparent header, why a queue hop often splits a trace in two, and how sampling shapes what you see.
~6 min readread →
Microservice Event Ordering and Partition Keys
Why one order's events arrive out of sequence without a partition key, what a key does and doesn't guarantee, and how versions catch the rest.
~6 min readread →
Microservice Idempotency Keys and Repeated Requests
How an Idempotency-Key header lets a client retry a payment POST safely: claim the key, fingerprint the body, replay the stored response.
~6 min readread →
Microservice Migration Through Incremental Boundaries
Extracting one capability at a time from a monolith: cut the seam in-process, move the data owner, compare in a parallel run, then switch.
~7 min readread →
Microservices Transactional Outbox and Event Delivery
Why saving an order and then publishing its event can lose messages, and how an outbox row in the same transaction trades loss for duplicates.
~6 min readread →
Microservice Read Models and Eventual Consistency
Building query views from events, why a user can't see the order they just placed, and how position tokens and idempotent projectors help.
~6 min readread →
Microservice Failure Tests and Recovery Evidence
Fault-injection experiments with a hypothesis, steady-state metrics and abort conditions, and why injected latency finds bugs errors miss.
~6 min readread →
Microservice Retry Budgets and Amplification
How three layers of retries turn one failing request into 64 database calls, and how a 10% retry budget caps extra load during outages.
~6 min readread →
Microservice Sagas and Compensation Limits
Running an order saga across inventory and payments, ordering steps around the pivot, and what compensations can't undo: emails, fees, reads.
~6 min readread →
Microservice Boundaries and Business Capabilities
Drawing service boundaries around business capabilities, not entities or layers, with change history as evidence and signs a split is wrong.
~5 min readread →
Microservice Discovery and Changing Endpoints
How callers find instances whose addresses keep changing (registries, TTLs, caches, DNS) and why a crashed instance still gets traffic.
~6 min readread →
Microservices: Synchronous Calls Versus Messaging
When a service should call another and wait, when it should publish an event instead, and what availability math and an email outage show.
~6 min readread →
MongoDB Aggregation Pipeline Stage Order
Why $match before $group can change your answer, what the MongoDB optimizer reorders for you, and how to order stages for speed safely.
~6 min readread →
MongoDB ObjectId and Identifier Semantics
What the 12 bytes of an ObjectId contain, why its timestamp is not a reliable clock, and when to choose your own _id in MongoDB.
~6 min readread →
MongoDB Compound Indexes and Query Order
How field order in a MongoDB compound index decides which queries it serves, with the equality, sort, range rule worked through step by step.
~6 min readread →
MongoDB Single-Document Atomicity and Updates
Why one MongoDB update is all-or-nothing for a document, how conditional updates stop lost writes, and where single-document atomicity ends.
~5 min readread →
MongoDB Embedding Versus Referencing
How to decide whether related MongoDB data goes inside one document or in its own collection, based on access patterns, growth and ownership.
~6 min readread →
MongoDB Explain Plans and Examined Documents
How to read MongoDB explain output: the plan stages, keys and documents examined versus returned, and what each pattern tells you to fix.
~6 min readread →
MongoDB Lookup and Relationship Cost
What $lookup really does per input document, why an index on the foreign field matters, and when to reshape data instead of joining.
~5 min readread →
MongoDB Missing Fields Versus Null
Why { field: null } in MongoDB also matches documents without the field, and how $exists and $type let you tell missing and null apart.
~5 min readread →
MongoDB Multikey Indexes for Array Fields
How MongoDB indexes every array element, why $elemMatch matters for arrays of subdocuments, and the parallel-array limit on compound indexes.
~5 min readread →
MongoDB Cursor Pagination and Stable Ordering
Why skip-based paging in MongoDB gets slower and drops rows, and how a range cursor on a unique sort key gives stable, fast pages.
~5 min readread →
MongoDB Partial Indexes and Subset Queries
How MongoDB partial indexes shrink an index to the documents you query, when the planner can use them, and how they give conditional uniqueness.
~5 min readread →
MongoDB Read Concern and Consistency Expectations
What local, majority, linearizable and snapshot read concerns promise in MongoDB, and how sessions give read-your-own-writes on secondaries.
~5 min readread →
MongoDB Replica Sets and Primary Elections
How a MongoDB replica set notices a dead primary, elects a new one in seconds, and what your app sees: errors, retries and rolled-back writes.
~5 min readread →
MongoDB Schema Validation and Flexible Records
How to add $jsonSchema validation to a MongoDB collection, roll it out safely with moderate and warn modes, and still allow flexible fields.
~5 min readread →
MongoDB Shard Keys and Workload Distribution
How to choose a MongoDB shard key with enough cardinality, even writes and targeted reads, and what to do when the first choice turns out wrong.
~6 min readread →
MongoDB Transactions and Data Modeling
When a MongoDB multi-document transaction is the right tool, what it costs, how to retry it correctly, and when a better model removes the need.
~5 min readread →
MongoDB TTL Indexes and Eventual Expiration
How MongoDB's TTL monitor deletes expired documents, why they can linger past their deadline, and how to filter, tune and size expiry safely.
~5 min readread →
MongoDB Unique Indexes and Domain Constraints
Why a MongoDB unique index beats a find-then-insert check, how missing fields and case break it, and how to handle E11000 errors cleanly.
~5 min readread →
MongoDB Unwind and Expanded Results
How $unwind turns one MongoDB document into one per array element, why that inflates sums and counts, and how to avoid double counting.
~6 min readread →
MongoDB Write Concern and Acknowledgement
What w: 1, w: "majority" and j: true actually promise in MongoDB, what a wtimeout error means, and how to pick a write concern per operation.
~5 min readread →
HTTP Connection Reuse and Latency
Measure what keep-alive saves, size a client connection pool with Little's law, and retry safely when a pooled socket was closed under you.
~6 min readread →
CORS and Browser Response Access
CORS decides whether a page may read a cross-origin response, not whether it is sent. A browser test shows a blocked POST still saved.
~6 min readread →
DNS Resolution and Cached Answers
Follow one DNS lookup from your laptop to the authoritative server with dig, and see why two users can get different answers after a move.
~6 min readread →
HTTP ETags and Conditional Requests
Use ETags for cheap 304 revalidation and to stop lost updates with If-Match, shown with curl against a small server that two editors share.
~6 min readread →
HTTP Cache-Control and Response Freshness
Who may store a response, how long it stays fresh and when it must be revalidated, shown with a toy CDN that leaks one user's page to another.
~6 min readread →
HTTP Cookies, Scope and Browser Delivery
How Domain, Path, Secure, SameSite and expiry decide which requests carry a cookie, with curl's cookie jar showing each rule in action.
~6 min readread →
HTTP Methods, Safety and Idempotence
Safe and idempotent HTTP methods explained by sending POST, PUT, PATCH and DELETE twice to a real server, then making POST retries safe.
~6 min readread →
HTTP Status Codes and Client Decisions
Read HTTP status codes as instructions: retry, fix the request, re-authenticate or check first, with a client decision function and its output.
~7 min readread →
HTTP Multiplexing and Transport Trade-Offs
HTTP/2 removes HTTP-level head-of-line blocking, but TCP's remains. See both in Node and curl, then compare what HTTP/3 over QUIC changes.
~6 min readread →
Network Latency Versus Bandwidth
Why a gigabit connection doesn't make chatty APIs fast: count round trips, compare them with transfer time, and fix whichever term dominates.
~6 min readread →
Network Debugging Along the Request Path
Find the first failing step in a request (DNS, TCP, TLS, HTTP or the app) with curl timings, dig, nc and openssl, using six real failures.
~6 min readread →
HTTP Preflight Requests and Allowed Operations
What makes a browser send an OPTIONS preflight, how the server's answer gates the real request, and five preflights traced in a real browser.
~6 min readread →
Reverse Proxies and Trusted Forwarded Headers
Behind a reverse proxy your app sees the wrong scheme and client IP. Learn to read X-Forwarded-* safely, with a spoofing test you can run.
~6 min readread →
TCP Byte Streams and Message Framing
Why three socket writes can arrive as one read and one write as seventeen, and how to frame messages with delimiters or length prefixes.
~6 min readread →
Server-Sent Events and One-Way Updates
How Server-Sent Events stream updates over plain HTTP, how EventSource resumes with Last-Event-ID after a drop, and what proxies do to streams.
~6 min readread →
TCP Connections and the Handshake
What SYN, SYN-ACK and ACK agree on, why the kernel finishes the handshake before your app runs, and how refused differs from timed out.
~6 min readread →
Network Timeouts and Operation Deadlines
Connect, first-byte, idle and total timeouts catch different failures. See each one fire against a stalling server, then budget retries sensibly.
~6 min readread →
TLS Encryption and Server Identity
Why encryption without a hostname check protects nothing, what a client verifies in a certificate, and the right fix for each TLS error.
~6 min readread →
UDP Delivery and Application Responsibilities
What UDP gives up compared with TCP, shown with real Node experiments, and the sequencing, pacing and retry work your application takes on.
~6 min readread →
WebSockets and Long-Lived Connection Ownership
The WebSocket lifecycle from the 101 handshake to heartbeats, close codes and resuming after a drop, plus which server owns each connection.
~7 min readread →
Node.js AsyncLocalStorage for Request Context
Use AsyncLocalStorage to keep a request ID in every log line, see why a module-level variable mixes requests, and find where context gets lost.
~7 min readread →
Node.js Blocking Work and Request Latency
Why a 170 ms synchronous loop in one Node.js request delays every other request, how to measure loop delay, and when to chunk or use workers.
~6 min readread →
Node.js Request Body Validation and Limits
Read a JSON request body in Node.js with a byte limit that also catches chunked uploads, then validate its shape and return 413, 415, 400 or 422.
~6 min readread →
Node.js Buffers and Text Encoding Boundaries
Why decoding each chunk with toString() corrupts non-ASCII text, how StringDecoder fixes it, and when Node.js bytes must never become strings.
~6 min readread →
Node.js Child Processes and Argument Safety
How a filename becomes shell injection with exec, why execFile and spawn with argument arrays avoid it, and the -- trick for argument injection.
~6 min readread →
Node.js Database Pools and Concurrency
Size a Node.js database pool from the database's capacity, see why a pool of 100 only moves the queue, and find the leak that hangs it.
~6 min readread →
Node.js Async Errors and Operation Boundaries
Where async errors escape try/catch in Node.js, why a floating promise kills the process, and how to wrap causes and catch at one boundary.
~6 min readread →
Node.js File Paths and Traversal Prevention
Why path.join doesn't stop ../ traversal, how a startsWith check and a symlink both leak files, and a Node.js containment check that holds up.
~6 min readread →
Node.js Graceful Shutdown and In-Flight Requests
What happens to an in-flight request when Node.js gets SIGTERM, how server.close drains it, and the container details that break shutdown.
~6 min readread →
Node.js Health Checks and Service Readiness
Separate liveness from readiness in Node.js, bound dependency checks with timeouts and caching, and avoid probes that restart healthy pods.
~6 min readread →
Node.js HTTP Timeouts and Resource Limits
Node's HTTP server and fetch timeout defaults, why headersTimeout fired after 30 seconds instead of 1, and how to set deadlines on both sides.
~6 min readread →
Node.js ESM and CommonJS Boundaries
How Node.js decides whether a file is ESM or CommonJS, why ESM imports need file extensions, and what require(esm) changes in Node 22 and later.
~6 min readread →
Node.js Package Exports and Public APIs
Define a Node.js package's public API with the exports field: subpaths, import and require conditions, blocked deep imports and dual builds.
~6 min readread →
Node.js Latency Measurement and Event Loop Delay
Measure Node.js latency without fooling yourself: monotonic clocks, percentiles over averages, coordinated omission, and event loop delay and ELU.
~7 min readread →
Node.js Pipeline and Stream Error Ownership
Why .pipe() leaks the source when a destination fails, what pipeline() destroys for you, and what a client sees when an export breaks halfway.
~6 min readread →
Node.js Environment Variables and Configuration
process.env holds only strings, so Boolean('false') is true and PORT=8080abc parses. Validate config once at startup and fail with every error.
~6 min readread →
Node.js Streams and Backpressure
What write() returning false means, how ignoring it buffered 193 MB for one slow client, and why awaiting drain alone hangs on a disconnect.
~6 min readread →
Node.js Test Isolation and Async Completion
Why an unawaited assert.rejects passes, how one unclosed server hung a test file, and node:test patterns that keep each test's state its own.
~7 min readread →
Node.js Timers and Scheduling Guarantees
setTimeout promises a minimum delay, not a time. Measured drift, skipped interval ticks, and how to build a countdown that stays correct.
~7 min readread →
Node.js Worker Threads and CPU Parallelism
On Node 22 a worker cut main-thread lag from 455 ms to 1 ms, yet a new worker per tiny task was 550x slower. Build a bounded pool instead.
~7 min readread →
Condition Variables and Predicate-Based Waiting
Why a condition variable wait sits in a while loop under the lock, with Python runs of a stolen wakeup, a lost notify and a notify() deadlock.
~6 min readread →
Context Switching and Scheduling Overhead
What a context switch saves and loses, voluntary vs involuntary switches, a 3.5 µs pipe ping-pong on an M1, and the real cost of 512 threads.
~6 min readread →
CPU Scheduling and Response-Time Goals
FIFO, SJF, STCF and round robin simulated with real numbers, the turnaround vs response trade-off, and what an M1's efficiency cores add.
~7 min readread →
Deadlock Conditions and Lock Ordering
Reproduce a two-account deadlock in Python, map it to the four Coffman conditions, and fix it with lock ordering, timeouts or a different design.
~6 min readread →
File Descriptors and Resource Exhaustion
What a file descriptor points to, which limits apply, and a real EMFILE reproduced in a throwaway process, plus how to find the leak with lsof.
~6 min readread →
Filesystem Writes, Buffers and Durability
What write, fsync and F_FULLFSYNC really promise, measured on an M1 (2 µs, 25 µs, 3.8 ms), plus atomic file replacement and group commit.
~6 min readread →
Interrupts and Device Completion Notifications
From a NIC interrupt to the thread that reads the data: top halves, deferred work, and a polling vs blocking test showing the CPU-latency trade.
~7 min readread →
Interprocess Communication and Data Transfer Trade-Offs
Pipes, Unix sockets, TCP loopback and shared memory compared on a 64 MiB transfer, plus the synchronization and trust costs each one carries.
~7 min readread →
Mutexes Versus Semaphores and Resource Ownership
A mutex has an owner, a semaphore counts permits. Real Python and pthread runs show why that matters for releasing, over-release and debugging.
~6 min readread →
Operating-System Page Cache and I/O Measurements
Random 4 KiB reads took 189 µs cold and 1.6 µs warm on an M1. How the page cache works, how to benchmark around it, and when to bypass it.
~7 min readread →
Paging, Page Faults and Memory Access
Minor, major and invalid page faults, with real counts: 4,096 faults for 64 MiB on an M1, and a cold mmap read 34 times slower than warm.
~6 min readread →
Priority Inversion and Lock Ownership
How a medium-priority task blocks an urgent one via a lock it never touches, simulated tick by tick, plus priority inheritance and Pathfinder.
~7 min readread →
Processes Versus Threads and Shared State
What a process owns, what its threads share, and what that costs: macOS runs of thread vs fork vs spawn, and a segfault that kills a process.
~7 min readread →
Producer-Consumer Queues and Backpressure
Unbounded, blocking and dropping queues measured in Python: how a bound turns overload into a policy, how to size it, and how to shut it down.
~7 min readread →
Race Conditions and Atomic State Transitions
Lost updates and check-then-act races, run in Node and Python: why a racy counter can pass tests, and how atomics, locks and O_EXCL fix it.
~6 min readread →
Stack Versus Heap Allocation and Lifetimes
Stack and heap as lifetime decisions: real addresses, stack overflows at 7,600 vs 400 frames on macOS, and a dangling pointer clang flags.
~6 min readread →
Starvation, Fairness and Scheduling Policy
A reader-preference lock starved a writer for 1.9 s in Python. Where starvation comes from, what fairness costs, and how schedulers bound it.
~6 min readread →
User Mode, Kernel Mode and Privileged Operations
How the CPU stops your code doing privileged work, what a system call costs, and why clock_gettime skips the kernel, with real M1 measurements.
~6 min readread →
Virtual Memory and Address-Space Isolation
Why two processes can hold different values at the same address, how page tables translate it, and why a 32 GiB mapping can cost almost nothing.
~6 min readread →
Working Sets and Memory Thrashing
Why throughput collapses when active memory exceeds RAM: in an LRU test, one frame fewer took faults from 2% to 100%. How to spot and fix it.
~7 min readread →
Python Asyncio and Blocking Functions
Why time.sleep or a sync HTTP call inside a coroutine freezes every task, how to spot it with debug mode, and when to_thread is enough.
~6 min readread →
Python Asyncio Tasks and Cancellation
Who owns an asyncio task: why fire-and-forget loses errors, how TaskGroup cancels siblings, and why swallowing CancelledError hangs shutdown.
~6 min readread →
Python Closures and Late Binding
Why lambdas created in a loop all return the last value, what a closure cell really stores, and the three clean ways to capture a value.
~5 min readread →
Python Comprehensions and Readable Transformations
How list, dict and set comprehensions scope their variables, why one fails in a class body, and when a plain loop is the better choice.
~5 min readread →
Python Context Managers and Resource Ownership
What the with statement guarantees, how __exit__ can swallow exceptions, the missing try/finally in @contextmanager, and ExitStack.
~6 min readread →
Python Shallow Copies and Nested Mutability
Assignment, shallow copy and deepcopy compared on a nested config dict, plus the [[0]*3]*3 grid bug and what deepcopy costs in practice.
~5 min readread →
Python Dataclasses and Mutable Fields
Why a list default fails in a dataclass, what frozen=True does and doesn't protect, and how eq and hash decide if instances can be keys.
~5 min readread →
Python Decorators and Function Metadata
A decorator replaces your function, so it owes callers the same return value, exceptions and metadata. functools.wraps and async cases.
~5 min readread →
Python Exception Chaining and Diagnostic Context
How raise ... from e, implicit chaining and from None shape a traceback, what __cause__ and __context__ hold, and when add_note is better.
~6 min readread →
Python Generators and Single-Pass Iteration
A generator runs nothing until the first next(): why validation fires late, how lazy pipelines pull one item at a time, and why they empty.
~5 min readread →
Python Hashability and Dictionary Keys
What makes a Python object usable as a dict key or set member, why defining __eq__ removes __hash__, and how a mutated key gets lost.
~5 min readread →
Python Identity Versus Equality
is checks for the same object and == asks the object whether values match. Small-int caching, interning, None checks and sentinels.
~5 min readread →
Python Imports and Side Effects
An import runs the module's top-level code once and caches it. Config read too early, circular imports, __main__ guards and importtime.
~6 min readread →
Python Iterators and Exhaustion
Iterables versus iterators: why map, zip, files and csv readers empty after one pass, how zip and in eat items, and how to design for it.
~5 min readread →
Python Mutable Defaults and Shared State
Why def f(x, items=[]) keeps growing between calls, where Python stores that list, the None-sentinel fix, and why tags or [] is subtly wrong.
~5 min readread →
Python Pathlib and Safe File Selection
Joining a user-supplied name onto a base Path can escape it via .., absolute paths or symlinks. Contain it with resolve() and is_relative_to.
~5 min readread →
Python Stable Sorting and Key Functions
How Python's stable sort keeps ties in order, multi-key sorts with tuples or two passes, reverse=True versus [::-1], and None in keys.
~5 min readread →
Python Test Fixtures and State Isolation
Why a test passes alone and fails in the suite: leaked module state, environment and files. Fix it with fixtures, scopes and cleanups.
~6 min readread →
Python Threads, Processes and Workload Choice
Measured on Python 3.14: threads speed up I/O waits but not pure-Python CPU work, processes do, and the GIL still allows lost updates.
~6 min readread →
Python Virtual Environments and Reproducible Dependencies
What python -m venv creates on disk, why activation only edits PATH, why python -m pip beats pip, and how lock files make installs repeatable.
~5 min readread →
React Dialogs: Focus, Escape and Restoration
Build an accessible React modal: native dialog with showModal, focus on open, Escape to close, focus restoration and testing with keyboard only.
~7 min readread →
React UseCallback and Captured Values
How useCallback dependencies decide which state a callback sees, why an empty array freezes stale values, and when useCallback is worth it.
~6 min readread →
React Context Scope and Update Costs
Which components re-render when a React context value changes, why an inline value object re-renders every consumer, and how to scope providers.
~6 min readread →
Controlled vs Uncontrolled Inputs in React
Compare controlled and uncontrolled React inputs with examples, reset behavior, checkbox handling and fixes for the uncontrolled-to-controlled warning.
~3 min readread →
React Custom Hooks and Shared Logic
Designing React custom hooks: they share logic not state, the use prefix rule, stable return values, and documenting what callers must pass.
~6 min readread →
React Derived Values Without Extra State
Stop syncing state with useEffect: compute filtered lists, totals and validity during render in React, and use useMemo only for real cost.
~6 min readread →
React Effect Cleanup and Subscription Ownership
When React runs useEffect cleanup, why Strict Mode mounts twice, and how to clean up listeners, timers, sockets and fetches without leaks.
~6 min readread →
React Effect Dependencies and Synchronization
How the useEffect dependency array really works: Object.is comparison, why objects re-run effects, and fixing deps without lint suppression.
~6 min readread →
React Error Boundaries and Recovery Scope
What React error boundaries catch and miss, where to place them so one failing widget does not blank the page, and how to reset after errors.
~6 min readread →
React External Stores and Consistent Snapshots
How useSyncExternalStore subscribes React to an external store without tearing, why getSnapshot must be cached, and how server snapshots work.
~6 min readread →
React Fetch Race Conditions: Cleanup and AbortController
Fix out-of-order React fetch results with cleanup and AbortController. Includes loading states, error handling and a practical interview explanation.
~3 min readread →
React Hydration and Matching Initial Content
What causes React hydration mismatch errors: dates, random ids, window checks and bad HTML nesting, plus fixes with useId, effects and Suspense.
~6 min readread →
React Layout Effects for DOM Measurement
useLayoutEffect vs useEffect: measure DOM size before paint to position tooltips without flicker, and know its cost and server rendering caveats.
~6 min readread →
React List Keys and Component Identity
Why React list keys matter: how index keys attach state to the wrong row after deletes or reordering, and how to pick a stable, unique key.
~6 min readread →
React Memo and Reference Stability
Why React.memo still re-renders: inline objects, arrow functions and children break shallow comparison, and how to keep props stable.
~6 min readread →
React Reducers and Valid State Transitions
When to choose useReducer over useState: model status as one field, reject impossible transitions in the reducer, and test it in plain Node.
~6 min readread →
React Refs Versus State for Mutable Values
useRef vs useState in React: refs change without re-rendering, state drives the UI. Learn which values belong where, with timer and DOM examples.
~6 min readread →
React Resetting Forms With Component Keys
Reset a React form when the selected record changes by giving it a key: how keys control state identity and why useEffect resets go wrong.
~6 min readread →
React State Snapshots and Event Handlers
Why setCount(count + 1) twice adds only one in React: how each render captures a state snapshot and how the update queue resolves it.
~7 min readread →
React Suspense Boundaries and Loading Ownership
Where to place React Suspense boundaries: what suspends, how fallbacks reveal, avoiding spinner waterfalls, and how transitions keep old content.
~6 min readread →
React Transitions and Urgent Input Updates
useTransition explained: keep typing responsive by marking heavy renders as non-urgent, why input state stays urgent, and useDeferredValue.
~6 min readread →
React Functional Updates and Pure State Changes
Why React updater functions like setItems(prev => ...) must be pure, why Strict Mode calls them twice, and how mutation causes duplicates.
~6 min readread →
ServiceNow ACLs and Record Access Decisions
How ServiceNow decides record access: table ACLs before field ACLs, the most specific match wins, and why server scripts skip the check.
~7 min readread →
ServiceNow Approvals and Decision Traceability
Model ServiceNow approvals so each decision is tied to the version reviewed: approval rules, rejection paths, timeouts and re-approval.
~7 min readread →
ServiceNow Automated Test Framework and Release Evidence
Design ATF tests that prove behaviour as real roles, know what rollback leaves behind, and keep suite results as release evidence.
~7 min readread →
ServiceNow Business Rule Timing and Side Effects
When ServiceNow business rules run: before rules shape the record, after rules touch others, async rules move slow work off the save.
~6 min readread →
ServiceNow Client Scripts Versus Server Enforcement
Client scripts and UI policies guide users on the form; ACLs, data policies and business rules enforce rules on every path into the data.
~6 min readread →
ServiceNow CMDB Identification and Data Quality
Keep one server as one CI: identification rules decide what's new, reconciliation rules decide which source owns each attribute.
~7 min readread →
ServiceNow Flow Designer and Workflow Ownership
Pick the right Flow Designer trigger and run option, avoid duplicate flows on one table, and build flows that a team can own and debug.
~7 min readread →
ServiceNow GlideAggregate for Summary Queries
Count and summarise ServiceNow records in the database with GlideAggregate instead of looping over every row, and avoid its string-typed results.
~6 min readread →
ServiceNow GlideAjax and Asynchronous Client Calls
Call server logic from a ServiceNow form with GlideAjax: a small JSON contract, validated parameters, and callbacks that ignore stale replies.
~7 min readread →
ServiceNow GlideRecord Queries and Bounded Results
Write GlideRecord queries that fetch only what you need: catch invalid fields, stop encoded-query injection, avoid N+1 lookups and use setLimit.
~8 min readread →
ServiceNow Import Sets and Transform Maps
Load external data into ServiceNow without duplicates: staging tables, coalesce on a stable key, reference choice actions and safe re-runs.
~8 min readread →
ServiceNow Incident, Problem and Change Roles
Incident restores service, problem finds the cause, change governs the fix: one outage traced through all three ServiceNow records.
~7 min readread →
ServiceNow Integrations and Retry-Safe Operations
Make ServiceNow outbound calls safe to retry: treat timeouts as unknown, send an idempotency key, back off, and keep calls out of the save.
~8 min readread →
ServiceNow Reference Fields and Record Identity
A ServiceNow reference field stores a sys_id and shows a display value. Treating the name as the identity causes most reference bugs.
~6 min readread →
ServiceNow Business Rule Conditions and Scope
Narrow ServiceNow business rule conditions to the transition you mean: operations, filters, changes() and changesTo(), and rules on task tables.
~7 min readread →
ServiceNow Scoped Applications and Cross-Scope Access
How ServiceNow application scopes protect tables and scripts, how cross-scope privileges work, and how to expose a small API to other apps.
~8 min readread →
ServiceNow Script Includes and Reusable Server Logic
Design ServiceNow script includes with explicit inputs and plain results, so business rules, flows and GlideAjax can share one implementation.
~7 min readread →
ServiceNow Table Inheritance and Shared Behavior
Child tables in ServiceNow inherit fields, rules and access from their parents. See what extending task gives you and what it costs.
~7 min readread →
ServiceNow UI Policies and Form Behavior
How ServiceNow UI policies decide visible, mandatory and read-only: evaluation order, Reverse if false, and why overlapping policies fight.
~7 min readread →
ServiceNow Update Sets and Deployment Scope
Know what a ServiceNow update set carries and what it leaves behind: configuration versus data, preview problems and environment values.
~7 min readread →
Spring Actuator Exposure and Operational Access
Which Spring Boot Actuator endpoints to expose, how exposure differs from authorization, and how to lock down env, heapdump and health details.
~6 min readread →
Spring Boot Auto-Configuration and Explicit Overrides
How Spring Boot auto-configuration works: AutoConfiguration.imports, @ConditionalOnMissingBean, the conditions report, and safe overrides.
~6 min readread →
Spring Bean Scopes and Shared Mutable State
Spring bean scopes explained: why singletons must be stateless, injecting prototype or request beans into singletons, and scoped proxies.
~6 min readread →
Spring Configuration Properties and Validation
Bind Spring Boot settings to typed @ConfigurationProperties records, validate them at startup, and know when @Value is still the right tool.
~6 min readread →
Spring Constructor Injection and Required Dependencies
Why Spring recommends constructor injection over @Autowired fields: final dependencies, plain unit tests, fail-fast startup and visible cycles.
~6 min readread →
Spring CSRF Protection and Authentication Transport
When Spring Security CSRF protection is needed: cookie sessions vs bearer tokens, SameSite, CookieCsrfTokenRepository and SPA setups in Boot 3.
~6 min readread →
Spring Controller Advice and Error Responses
Map Spring Boot exceptions to stable HTTP errors with @RestControllerAdvice and ProblemDetail, without leaking stack traces or internals.
~6 min readread →
Spring HTTP Clients and Deadline Ownership
Set connect and read timeouts on Spring RestClient and WebClient, size them from a latency budget, and stop slow calls exhausting threads.
~7 min readread →
Spring JPA Lazy Loading and Session Boundaries
Why Hibernate throws LazyInitializationException in Spring Boot, how open-in-view hides it, and how fetch joins, entity graphs and DTOs fix it.
~6 min readread →
Spring JPA N-Plus-One Query Diagnosis
Detect and fix JPA N+1 selects in Spring Boot with fetch joins, @EntityGraph, batch fetching and DTO queries, then prove it with a test.
~6 min readread →
Spring Metrics Tags and Cardinality
Why unbounded Micrometer tags like user IDs or raw URLs blow up Prometheus, how Spring Boot templates URIs, and how to cap tag cardinality.
~6 min readread →
Spring JPA Optimistic Locking and Conflicts
How JPA @Version prevents lost updates in Spring Boot, what ObjectOptimisticLockingFailureException means, and when to retry or return 409.
~6 min readread →
Spring Profiles and Environment Differences
Use Spring Boot profiles for environment differences without hiding behaviour: profile files, @Profile beans, groups, and config precedence.
~6 min readread →
Spring Repository Tests and Database Fidelity
What @DataJpaTest loads, why its rollback and embedded database can hide bugs, and how to test Spring Data repositories with Testcontainers.
~6 min readread →
Spring REST Validation at Request Boundaries
Validate Spring Boot request bodies and parameters with @Valid and Jakarta constraints, return clear 400 errors, and avoid silent gaps.
~6 min readread →
Spring Transaction Rollback Rules and Exceptions
Why Spring @Transactional commits on checked exceptions, how rollbackFor and noRollbackFor work, and why swallowed exceptions commit.
~6 min readread →
Spring Security Filter Chains and Endpoint Policy
How Spring Security 6 SecurityFilterChain beans work: lambda DSL, securityMatcher, @Order, rule ordering and why the first matching chain wins.
~6 min readread →
Spring Startup Checks and Readiness
How Spring Boot liveness and readiness probes work on Kubernetes, what belongs in each health group, and how to warm up and shut down gracefully.
~6 min readread →
Spring Transaction Duration and Remote Calls
Why long @Transactional methods exhaust the Hikari pool and hold locks, and how to keep remote calls, files and email outside the transaction.
~7 min readread →
Spring Transactions and Proxy Invocation
Why @Transactional is ignored on self-invocation and private methods in Spring Boot, how the proxy works, and four ways to fix it.
~7 min readread →
SQL Aggregation and Result Grain
Why joining two one-to-many tables before SUM inflates totals, and how to aggregate each child table at its own grain before you combine them.
~6 min readread →
PostgreSQL Composite Indexes and Query Patterns
How column order in a PostgreSQL multicolumn B-tree decides which filters and sorts it serves, with real EXPLAIN plans from a million-row table.
~6 min readread →
SQL Constraints as Concurrent Safety Nets
Why check-then-insert in application code double-books under concurrency, and how UNIQUE, CHECK and exclusion constraints enforce the rule.
~6 min readread →
SQL Count Star Versus Count Column
COUNT(*) counts rows, COUNT(column) counts non-NULL values. See how that fixes LEFT JOIN counts and where COUNT(DISTINCT) misleads.
~6 min readread →
SQL Common Table Expressions and Query Structure
What a PostgreSQL CTE is for, when it's inlined or materialized since version 12, and how writable CTEs move rows in one statement.
~6 min readread →
SQL Exists for Relationship Checks
Use EXISTS when you're asking whether a related row exists: no duplicate rows, NULL-safe NOT EXISTS, and semi or anti joins in PostgreSQL plans.
~6 min readread →
PostgreSQL Explain Analyze and Real Execution
Read PostgreSQL EXPLAIN ANALYZE output: estimated versus actual rows, loops, buffers, and why ANALYZE really runs your DELETE, with real plans.
~6 min readread →
SQL Joins and Unexpected Row Multiplication
Predict how many rows a SQL join returns: duplicate lookup keys multiply rows, inner joins drop unmatched ones, and both can hide in one count.
~6 min readread →
SQL Keyset Pagination and Stable Ordering
Why OFFSET pages get slow and drift, and how keyset pagination with a unique tiebreaker and a row comparison stays fast at any depth.
~6 min readread →
SQL Left Joins and Filter Placement
A WHERE test on the right table quietly turns a LEFT JOIN into an inner join. See why, where the filter belongs, and how to spot it in a plan.
~6 min readread →
PostgreSQL MVCC, Old Versions and Vacuum
How PostgreSQL UPDATE writes a new row version, why dead tuples pile up, what VACUUM reclaims, and how one idle transaction stops cleanup.
~7 min readread →
SQL Normalization and Deliberate Denormalization
Normalize so each fact has one home, then denormalize on purpose with snapshots, trigger-kept counters and materialized views.
~6 min readread →
SQL Null and Three-Valued Logic
NULL makes comparisons unknown, not false. See how that drops rows from WHERE, empties NOT IN and slips past CHECK constraints.
~6 min readread →
PostgreSQL Partial Indexes for Focused Workloads
Index only the rows a hot query reads, such as pending jobs or active subscriptions, and learn when PostgreSQL can and can't use a partial index.
~6 min readread →
SQL Parameterization and Injection Prevention
Why bind parameters stop SQL injection, what they can't parameterize (table names, ORDER BY, LIKE wildcards), and how prepared plans behave.
~7 min readread →
SQL Row Number, Rank and Dense Rank
row_number, rank and dense_rank differ only when values tie. Pick the right one for top-N per group, second-highest and leaderboard queries.
~6 min readread →
PostgreSQL Row Locks and Concurrent Updates
Watch two PostgreSQL sessions lose an update, then fix it with an atomic UPDATE or FOR UPDATE, and see what NOWAIT and SKIP LOCKED do.
~7 min readread →
SQL Transaction Isolation and Observable Anomalies
Run Read Committed, Repeatable Read and Serializable side by side in PostgreSQL, from changing reads to write skew only Serializable stops.
~7 min readread →
PostgreSQL Upserts and Conflict Semantics
How INSERT ... ON CONFLICT behaves in PostgreSQL: conflict targets, EXCLUDED, version guards for stale writes, batch duplicates and MERGE.
~7 min readread →
SQL Window Functions Without Collapsing Rows
Window functions compute totals, running sums, LAG and moving averages next to each row. Learn PARTITION BY, frames, and the default-frame trap.
~7 min readread →
System Design API Contracts and Client Recovery
How an export API uses 202 Accepted, an operation resource and an idempotency key so a client that lost a response can recover safely.
~7 min readread →
System Design Cache-Aside and Stale Data
Cache-aside read and write paths, why you update the database before deleting the key, and the race that still leaves stale data until TTL.
~7 min readread →
System Design Cache Stampedes and Refill Coordination
Why a hot key expiring under 5,000 requests a second sends 1,500 queries to the database, and how locks, early refresh and jitter stop it.
~7 min readread →
System Design Capacity Estimates and Assumptions
A worked back-of-envelope estimate for a photo app: peak requests per second, storage per year, egress bandwidth and how wrong it might be.
~6 min readread →
System Design CDNs and Cacheable Content
Which responses a CDN may share, how Cache-Control and the cache key decide it, and why a stray utm_source parameter can halve your hit ratio.
~6 min readread →
System Design Consistency and User Expectations
Read-your-writes, monotonic reads and linearizability tied to real product decisions, with a replica-lag simulation of what users see.
~6 min readread →
System Design Graceful Degradation and Correctness
Classify each dependency as required or optional, set timeouts that bound bad days, and design fallbacks that never show users false data.
~6 min readread →
System Design Reviews Through Concrete Failure Cases
Run a design review by tracing one timed-out order through every hop, then turn what breaks into a failure table and a short list of fixes.
~7 min readread →
System Design Feeds and Fanout Trade-Offs
Fan-out on write versus read for a 20-million-user feed, with simulated insert rates, a 13.7M-follower post and where a hybrid threshold goes.
~6 min readread →
System Design IDs and Ordering Requirements
Snowflake IDs, UUIDv4 and UUIDv7 compared with runnable code: collision odds, 4,096 IDs per millisecond, and why clock skew breaks ordering.
~6 min readread →
System Design Load Balancing and Healthy Capacity
Round robin, least outstanding and power of two choices simulated with uneven request costs, plus health checks and long-lived connections.
~6 min readread →
System Design Multi-Region Recovery and Data Risk
RPO and RTO with real arithmetic: how many writes async replication loses at failover, a minute-by-minute recovery budget, and fencing.
~6 min readread →
System Design Observability and Failure Questions
Design metrics, traces and logs from the questions on-call engineers ask: SLO burn-rate math, label cardinality and tracing across a queue.
~6 min readread →
System Design Partitioning and Hot Keys
Choosing a partition key, why hash mod N moves 91% of keys when you add a node, how consistent hashing fixes it, and how to split a hot key.
~6 min readread →
System Design Queues and Backlog Management
A minute-by-minute export queue during a month-end burst: backlog growth, drain time, age of oldest message and how poison messages eat workers.
~6 min readread →
System Design Rate Limiting and Fairness
Fixed window, sliding window and token bucket limiters run on the same burst, plus who to limit, enforcing across gateways and 429 responses.
~6 min readread →
System Design Replication and Read Freshness
Leader-follower replication in numbers: commit latency for sync and quorum acks, how a batch job builds 150 s of lag, and failover loss.
~6 min readread →
System Design Requirements Before Components
How to spend the first minutes of a design interview: questions that pin down scope, scale and correctness, and how answers reshape the design.
~7 min readread →
System Design Search Indexes and Source Ownership
Keep a search index in sync with its source database: change capture, external versions for late events, deletes and reindexing by alias.
~6 min readread →
System Design Uploads and Safe Completion
Design file uploads as a state machine: pre-signed URLs, multipart for flaky networks, quarantine and scanning, and why uploaded isn't ready.
~7 min readread →
Accessibility Tests Beyond Automated Scans
A hand-built modal passed axe with zero violations, then failed four keyboard and dialog checks in Playwright; a native dialog passed all five.
~7 min readread →
Arrange, Act and Assert for Clear Tests
Split each test into arrange, act and assert so a failure names one broken behavior, shown on an order-cancellation service with node:test.
~7 min readread →
Async Tests and Controlled Completion Order
Replace sleeps with deferred promises so an async test decides which response lands first, catching stale-result races on every run.
~7 min readread →
Testing Observable Behavior Instead of Implementation
A refactor breaks a test that spies on private helpers while a real bug slips past it; asserting results and stored state catches both cases.
~7 min readread →
Boundary-Value Tests and Off-By-One Errors
Test just below, at and just above every limit: a cart cap with a < that should be <=, plus a 50.00 threshold that floats quietly miss.
~6 min readread →
Contract Testing Across Independent Services
Consumer-driven contracts in practice: a shipping service records what it needs from orders, and a renamed field fails before deploy.
~7 min readread →
Database Tests and Representative Engine Behavior
SQLite accepted 'abc' as a price and a 16-character SKU that PostgreSQL rejects; test on the engine production uses, here via PGlite.
~7 min readread →
Equivalence Partitions for Efficient Test Coverage
Group inputs that behave alike, test one value per group, then check the code agrees: Python's int() also accepts '1_0', '+5' and ' 7 '.
~7 min readread →
Fake Timers and Clock-Based Behavior
Test debounces, cooldowns and retry backoff with node:test mock timers, and avoid the Date.now and promise traps that make fake clocks lie.
~7 min readread →
Test Fixtures and Independent State
A shared SQLite fixture makes tests pass alone and fail together; fix it with fresh state per test, commit-proof rollbacks and addCleanup.
~7 min readread →
Flaky Tests and Root-Cause Evidence
Diagnose flaky tests with evidence: measure the failure rate, compare a test alone and in the suite, and replace sleeps that fail 23 runs in 100.
~7 min readread →
Mocks, Stubs and Fakes: Dependency Test Choices
When to reach for a stub, a mock or a fake, shown on a password-reset service, plus a contract test that caught a fake more lenient than SQLite.
~7 min readread →
Mutation Testing and Assertion Strength
Stryker plants small bugs in code to see if tests notice: a shipping rule with 100% line coverage scored 72.73% until boundary tests went in.
~6 min readread →
Performance Tests and Realistic Workloads
Ramp load on a service with a 4-connection pool: throughput levels off near 190 req/s, and a fixed 300 req/s arrival rate ends in 85% timeouts.
~7 min readread →
Property-Based Testing and Useful Invariants
Property tests generate hundreds of inputs and shrink failures to tiny examples: fast-check finds JavaScript's default sort and a CSV bug fast.
~7 min readread →
Regression Tests and Change Risk
Write a regression test that fails for the original bug, select tests from the diff, and see when an import graph misses the one that breaks.
~6 min readread →
Security Tests for Rejected Operations
Test what each user must not do: a table-driven access matrix for an invoice API catches a missing ownership check that happy paths miss.
~7 min readread →
Unit, Integration and End-to-End Test Boundaries
Unit, integration and end-to-end tests differ in what runs for real; four green pricing tests missed a coupon bug that one API-level test caught.
~7 min readread →
Test Reports and Honest Coverage Claims
A green run with a skipped Stripe test and coverage that drops from 72.88% to 55.17% once test files are excluded: how to report what really ran.
~6 min readread →
Visual Regression Tests and Stable Comparisons
Screenshot tests with Playwright: freeze the clock and viewport, and see why a 2% tolerance that hides a timestamp lets a wrong price through.
~7 min readread →
TypeScript Branded IDs and Domain Safety
Why UserId and OrderId can both be strings yet must not be swapped, and how a branded type plus one parsing function makes TypeScript catch it.
~6 min readread →
TypeScript Testing Public Type Contracts
How to write tests that fail when a library's types regress: @ts-expect-error for rejected calls, an exact Equal helper, and running tsc in CI.
~5 min readread →
TypeScript Conditional Types and Distribution
How T extends U ? X : Y picks a type, why it splits unions apart member by member, and how wrapping both sides in brackets turns that off.
~6 min readread →
TypeScript Discriminated Unions for UI State
Replace isLoading, error and data flags with one status union so impossible UI states stop compiling and each branch sees only its own fields.
~6 min readread →
TypeScript Error Handling Without Unsafe Casts
Why strict mode types catch variables as unknown, how to narrow them without casting, and when a Result union beats throwing an error.
~5 min readread →
TypeScript Function Variance in Callbacks
Why a Dog handler can't stand in for an Animal handler, how strictFunctionTypes checks callbacks, and the method-syntax loophole it leaves.
~5 min readread →
TypeScript Generic Constraints and Relationships
Use extends to state what a generic needs, keyof to link one parameter to another, and see why 'a different subtype' errors appear.
~6 min readread →
TypeScript Infer for Type Extraction
How infer pulls element, return and parameter types out of other types, why readonly arrays don't match T[], and how to parse route strings.
~5 min readread →
TypeScript Keyof and Safe Property Access
Why indexing an object with a plain string fails (TS7053), how keyof typeof and T[K] fix it, and why Object.keys still returns string[].
~5 min readread →
TypeScript Literal Inference and Const Assertions
Why let and object properties widen "GET" to string, how as const keeps literals and readonly tuples, and what it does not do at runtime.
~5 min readread →
TypeScript Mapped Types and Modifiers
How { [K in keyof T]: T[K] } rebuilds a type, how ?, readonly, -? and -readonly change it, and why Partial stops one level down.
~5 min readread →
TypeScript Type Imports and Runtime Modules
What import type removes from emitted JavaScript, why verbatimModuleSyntax makes you write it, and the crash you get when you don't.
~5 min readread →
TypeScript Never and Exhaustive Checks
Use never to make TypeScript list every switch you forgot to update when a union grows, and choose between assertNever, satisfies and Record.
~5 min readread →
TypeScript Optional Properties and Presence
A missing key and a key set to undefined behave differently in spreads, JSON and the in operator; exactOptionalPropertyTypes makes types match.
~5 min readread →
TypeScript Readonly Collections and Ownership
What readonly arrays, ReadonlyMap and ReadonlySet block, why readonly is a view rather than a frozen copy, and how to share state safely.
~5 min readread →
TypeScript Satisfies Without Losing Inference
How satisfies checks an object against a type while keeping its exact keys and values, and how it differs from an annotation and from as.
~6 min readread →
TypeScript Null Narrowing Across Control Flow
How strictNullChecks narrows through returns, closures and filter calls, where it keeps a narrowing it shouldn't, and what to do about Map.get.
~6 min readread →
TypeScript Structural Typing and Excess Properties
TypeScript compares shapes, not names, so extra properties are usually fine; learn when the excess property check fires and when it doesn't.
~5 min readread →
TypeScript Tuples for Fixed Position Data
When a fixed-length array beats an object, why a returned [value, setter] pair needs a type or as const, and the push hole in tuples.
~5 min readread →
TypeScript Unknown at API Boundaries
Why res.json() and JSON.parse return any, how typing the result as unknown forces a real check, and how to write a type guard that holds up.
~5 min readread →
Frontend System Design: Build an Autocomplete
A structured walkthrough of the autocomplete design round: requirements, architecture, race-free fetching, caching, rendering, the ARIA combobox and metrics.
~7 min readread →
Closures, Scope & the Classic setTimeout Loop
What lexical scope and closures really are, why the var + setTimeout loop prints 3 3 3, three ways to fix it, and where closures earn their keep in real code.
~6 min readread →
TypeScript Generics, Explained Through Interview Questions
Ten generics questions, from constraints and keyof to infer, distributive conditional types and variance, each with a short answer and code you can reproduce.
~6 min readread →
The Event Loop: Microtasks vs Macrotasks
How the call stack, task queue and microtask queue fit together, where rendering happens, how async/await schedules work, and output puzzles with answers.
~7 min readread →
useEffect Pitfalls Interviewers Love to Ask
Stale closures, missing cleanup, fetch races, Strict Mode's double run, infinite loops and effects you don't need, plus how useLayoutEffect differs in timing.
~7 min readread →
The this Keyword: Four Binding Rules and One Exception
How JavaScript decides what this means: default, implicit, explicit and new binding, which one wins, why arrow functions ignore them, and the classic bugs.
~6 min readread →
Angular Change Detection, OnPush & Signals Demystified
How Angular decides when to update the DOM: the tree walk, what Zone.js did, what marks an OnPush component dirty, and how signals allow zoneless apps.
~7 min readread →
Hoisting, the TDZ and var vs let vs const
What the engine sets up before your code runs, why var reads undefined while let throws, how the temporal dead zone works, and why const isn't immutable.
~6 min readread →
type vs interface: When It Actually Matters
Declaration merging, extends vs intersections, what only type aliases can express, and the few differences that change behavior, with a clear rule of thumb.
~5 min readread →
React Reconciliation & Keys: What Really Happens
Render vs commit, the diffing rules React relies on, why index keys break inputs, how a key resets state, and what Fiber and batching change about updates.
~7 min readread →
Prototypes & Inheritance Without the Headache
How the prototype chain resolves properties, what __proto__ and prototype mean, what new and class do under the hood, and how to wire inheritance by hand.
~7 min readread →
switchMap vs mergeMap vs concatMap vs exhaustMap
The four RxJS flattening operators differ in one thing: what happens when a new value arrives while the previous inner observable is still running.
~6 min readread →
Implement Debounce and Throttle From Scratch
Build debounce and throttle the way interviewers expect: timelines, this and args, cancel(), leading and trailing edges, and how to test them.
~7 min readread →
Build TypeScript's Utility Types From Scratch
Rebuild Partial, Pick, Omit, Exclude, ReturnType, Awaited and friends with mapped and conditional types, plus modifiers, key remapping and template literals.
~6 min readread →
memo, useMemo and useCallback: When They Actually Help
Why components re-render, what memo really compares, how referential equality decides it all, when memoization is wasted, and where React Compiler fits.
~6 min readread →
Angular Dependency Injection: Providers, Scopes & inject()
How Angular finds a dependency: element and environment injectors, providedIn root, provider recipes, InjectionToken, resolution modifiers and singletons.
~7 min readread →
The Node.js Event Loop Phases, Explained
What libuv does on each turn of the loop, where nextTick, promises, setImmediate and timers really run, and how to keep CPU-heavy work from blocking it.
~7 min readread →
The Cascade, Specificity & the Box Model
How the browser decides which CSS rule wins (origin, @layer, specificity, order), how inheritance and box-sizing work, and why z-index can seem broken.
~7 min readread →
Write Promise.all (and Friends) From Scratch
Implement Promise.all with native semantics, then allSettled, race, any and a concurrency-limited pool, plus the edge cases interviewers probe.
~6 min readread →
Cheat sheets
JavaScript Essentials
48 must-know facts & snippets
open & print →
TypeScriptFrom unknown to infer, on one page
open & print →
TypeScript Utility TypesPartial → Awaited, all of them
open & print →
ReactRendering to Server Components, on one page
open & print →
React HooksEvery hook, one example each
open & print →
AngularSignals to guards, standalone-first
open & print →
RxJS OperatorsThe 30 operators you'll actually use
open & print →
HTML & CSSSemantics to grid, cascade to stacking
open & print →
Next.jsApp Router, RSC, caching and actions
open & print →
Node.jsEvent loop to streams, checked on Node 22
open & print →
JavaOOP to virtual threads, on one page
open & print →
Spring BootBeans to JWT and @Transactional, one page
open & print →
PythonCore Python to asyncio, on one page
open & print →
MicroservicesDDD to sagas, retries and tracing
open & print →
SQL & PostgreSQLJoins to MVCC, every query run on Postgres 16
open & print →
MongoDBBSON to sharding, with the defaults that matter
open & print →
GoGoroutines to generics, slices to context
open & print →
DockerDockerfile to Compose, layers to PID 1
open & print →
KubernetesPods to Helm, plus a troubleshooting table
open & print →
RedisData types to Cluster slots, Redis 7.4/8
open & print →
AWSEC2 to IAM to DR, the services that come up
open & print →
Git & CI/CDStaging area to canary deploys, on one page
open & print →
Apache KafkaPartitions to transactions, KRaft era
open & print →
ServiceNowGlideRecord to update sets, on one page
open & print →
Data Structures & AlgorithmsBig-O to DP, with Python templates
open & print →
System DesignRendering to caching, plus five mini-designs
open & print →
Statistics & Data ScienceBayes to CUPED, p-values to regression
open & print →
Machine LearningBias-variance to boosting, metrics to leakage
open & print →
Deep LearningBackprop to KV cache, Adam to LoRA
open & print →
AI & LLM EngineeringTokens to agents, RAG to guardrails
open & print →
MLOpsPipelines to PSI, registry to rollback
open & print →
Interview questions by topic
JavaScriptTypeScriptReactAngularHTML & CSSNode.jsJavaSpring BootPythonMicroservicesSQL & PostgreSQLMongoDBDockerKubernetesAWSGit & CI/CDServiceNowData Structures & AlgorithmsSystem DesignNetworkingOperating SystemsSoftware TestingBehavioral & HRNext.jsGoApache KafkaRedisMachine LearningDeep LearningAI & LLM EngineeringMLOpsStatistics & Data Science