Performance
39 guides tagged “Performance”.
- How to Speed Up CI Builds (Without Skipping Tests) Slow pipelines get bypassed. Cut time with dependency caching, parallel jobs, test splitting, and smaller images - not by disabling checks.
- How Many vCPUs Does My App Actually Need? Size from the process model and measured CPU time. A single-process web app often needs one or two vCPUs; the database needs headroom and fast disk.
- What Is a TOPS Score (and What Does It Actually Measure)? TOPS is a peak throughput figure that depends on precision, sparsity, and memory. It is not a measure of real model performance.
- What Is Prompt Caching (and How Much Does It Save)? Prompt caching reuses the model's processed prefix, charging less for repeated input. It only works when the stable part comes first.
- Serve Users in Asia Without the Round Trip An intermediate journey: pick an APAC region, put a Hong Kong edge in front, cut the bytes, cache correctly, and measure p95 from real cities.
- Connection Pool Exhausted: What It Is and How to Fix It Pool exhaustion means connections are held rather than missing. Learn why raising the limit makes it worse, how to find the leak, and the four real causes.
- What Is ReDoS (Regular Expression Denial of Service)? ReDoS is a denial-of-service attack that uses a badly written regular expression to burn CPU. Learn what catastrophic backtracking is and how to fix it.
- Offset vs Cursor Pagination: Which Should Your API Use? Offset pagination skips rows and drifts as data changes. Cursor pagination seeks directly and stays consistent. Compare them and learn when each is right.
- What Is a Memory Leak (and Why Does Your App Get Slower the Longer It Runs)? A memory leak is memory your app never releases. Learn why AI-generated code leaks it, how to find the cause, and how to fix it in Python and Node.js.
- The 12 Database Mistakes That Show Up in AI-Generated Apps Missing indexes, N+1 queries, float money, naive timestamps, unpooled connections, and destructive migrations — the twelve database mistakes generated code ships with, and the fix for each.
- Databases for AI Builders: Why Your AI-Generated App Gets Slow and Loses Data Your AI writes working SQL that fails at scale. Learn indexing, the N+1 problem, transactions, connection pools, migrations, backups, and consistency — with linked guides for each.
- Eventual Consistency vs Strong Consistency: What's the Difference (and When Does It Matter)? Strong consistency guarantees all readers see the same data immediately. Eventual consistency saves latency and availability but lets reads return stale data. Here's when each is the right call.
- Latency Numbers Every Developer Should Know The order-of-magnitude costs of memory, disk, network, and API calls — and why each step up the ladder is a different kind of slow.
- Why Is Your Docker Image So Large (and How Do You Shrink It)? A 1.5 GB Docker image is usually build cruft, not your app. Learn the four causes and the fixes that routinely cut images by 80%.
- What Is a Covering Index? An index that contains every column a query needs can answer it without visiting the table at all — an index-only scan, which is faster and cheaper than any ordinary index.
- Why Is My Website Suddenly Slow? A diagnostic order for sudden slowness: is it the network, the application, the database, or a resource that ran out — and how to tell in minutes.
- What Is a CPU (and Why More Cores Isn't Always Faster)? A CPU executes instructions one at a time per core. Learn what cores, clock speed, cache, and instruction sets actually do, and why a slower-looking chip often wins.
- Cores vs Threads: What Hyperthreading Actually Buys You A core executes; a thread is a stream of work. SMT lets two streams share one core, which helps some workloads and slows others. Here is what the spec sheet means.
- What Is RAM (and Why Does Your App Run Out of Memory)? RAM is the fast, temporary workspace every running program shares. Learn how capacity, bandwidth, and ECC differ, and why hitting the memory ceiling kills your app instantly.
- How a Program Actually Runs: From Your Python to the CPU What happens between pressing enter and the CPU doing work: bytecode, compilers, syscalls, the kernel, and why containers do not change any of it.
- What Is a Materialized View? A materialized view stores the result of a query as a table. It makes expensive reads fast at the cost of staleness and maintenance — and it is not the same as a view.
- What Is Memoization (and When Does It Actually Help)? Memoization caches a function's results by its arguments so repeat calls skip the work. Learn when it's a huge win and when it's wasted effort.
- How to Read an EXPLAIN Plan A step-by-step reading of a query plan: what each node does, which numbers matter, and how to spot the scan or the estimate that explains a slow query.
- Bits, Bytes, and Bandwidth: The Units Behind Every Spec Sheet Why a 512 GB drive shows 476 GB, why 1 Gbps is not 1 GB/s, and how to read a hardware spec sheet without being fooled by the units.
- How to Set Up Horizontal Pod Autoscaling (HPA) in Kubernetes Install the metrics server, set resource requests, create an HPA, and load test it until it actually scales — plus the tuning that stops it flapping and the checks that catch a silent failure.
- Why Does My Database Connection Time Out? Connection timeouts come from four places: the pool is exhausted, the database's connection limit is reached, the network blocks the path, or the server is too busy to accept.
- What Is a Cache Stampede? When a popular key expires, every request for it can miss at once and hit the database together. Here is how to detect and prevent the thundering herd.
- SSD vs HDD vs NVMe: What Storage Speed Actually Means Hard drives, SATA SSDs, and NVMe drives differ by more than a factor of a hundred. Learn which number matters for your workload and where cloud storage quietly hurts.
- How to Fix 'Too Many Connections' in Postgres 'Too many connections' means your app exhausted Postgres's connection limit. Learn the real causes, the quick fixes, and the permanent ones.
- What Are Serverless Cold Starts (and Do They Matter for You)? A cold start is the delay when a serverless function spins up for the first time. Learn why they happen, how long they take, and when they matter.
- Kubernetes Requests vs Limits: Why Your Pod Gets OOMKilled Resource requests tell the scheduler what to reserve; limits tell the runtime when to throttle or kill. Setting them wrong causes OOMKills, throttling, and eviction.
- Cache Invalidation Explained Stale data is the price of caching. Here are the strategies that keep it bounded — TTL, write-through, purge on write, versioned keys — and how to choose between them.
- What Is a Database Deadlock (and How Do You Fix It)? A deadlock is two transactions each holding a lock the other needs. The database detects it and kills one. Here is why generated code creates them and how to make them stop.
- Kubernetes Autoscaling Explained: HPA vs VPA vs Cluster Autoscaler Kubernetes has three autoscalers that answer three different questions. Learn which one scales replicas, which resizes pods, which adds nodes, and when autoscaling is the wrong fix.
- What Is a 504 Gateway Timeout (and How Do You Fix It)? A 504 means a proxy waited for an upstream server that did not answer in time. The fix is usually to make the slow operation faster, not to raise the timeout.
- How Much RAM Does a Web App Actually Need? A practical way to size memory from the runtime, the workload, and the concurrency — instead of guessing and watching the process get killed.
- What Is a CDN and Do You Need One? A CDN caches your site on servers near your visitors, making it load faster worldwide. When it matters, when it's overkill, and what it costs.
- What Is a Composite Index? A composite index covers several columns in a defined order. Which queries it can serve depends on the leftmost columns, which is why column order is the whole design decision.
- What Is a Connection Pool? A connection pool reuses database connections instead of opening one per request. Learn why your app hits 'too many connections' and how pooling fixes it.