Performance Optimization

Performance optimization starts with measuring where time and resources go. This hub groups Netdata's blog posts on the subject, from reading Linux CPU, load and pressure metrics to shortening investigations with automated troubleshooting.

Product

AI Reporting Software For Observability Data

Turn observability data into strategic intelligence with automated summaries, forecasts, and AI-driven incident analysis from Netdata. Read more now!

Guides

Guides overview 2 pages

Microsoft SQL Server Operations Guides

Practical guides for running, troubleshooting, and monitoring Microsoft SQL Server in production.

MongoDB Operations Guides

Practical guides for running, troubleshooting, and monitoring MongoDB in production.

Cassandra Operations Guides 4 pages

Open the Cassandra Operations Guides hub

Cassandra commitlog pending tasks: write-path I/O pressure

Diagnose and resolve sustained CommitLog PendingTasks in Apache Cassandra, where commitlog fsync bottlenecks delay write acknowledgments and cascade into dropped mutations.

Cassandra GC pauses too long: diagnosing G1 stop-the-world pauses

Diagnose and resolve long G1 stop-the-world pauses in Cassandra before they trigger gossip failures and client timeouts.

Cassandra heap pressure: sizing the JVM heap and tuning G1GC

Size the JVM heap and tune G1GC for Cassandra 4.x and 5.x to avoid GC pauses, gossip flapping, and the death spiral.

Cassandra hot partition: when one key saturates a replica set

Diagnose and mitigate hot partitions in Apache Cassandra when a single key concentrates traffic, saturating replicas and spiking tail latency.

ClickHouse Operations Guides 7 pages

Open the ClickHouse Operations Guides hub

ClickHouse Active Part Count Growing: How To Fix

Operational guide to diagnosing and stopping ClickHouse active part count growth before it triggers insert delays, throttling, or too-many-parts errors.

ClickHouse full table scan: partition pruning failures and the primary key

Diagnose why ClickHouse queries scan every row and how to fix partition pruning and primary key misalignment.

ClickHouse Memory limit (for query) exceeded: per-query limits and GROUP BY/JOIN blowups

Troubleshoot ClickHouse error code 241 when per-query memory limits breach, including high-cardinality GROUP BY, unbounded DISTINCT, and Cartesian-product JOINs.

ClickHouse mutations silently blocking merges: the hidden cause of part growth

Why ALTER UPDATE/DELETE mutations starve the merge pool, how to spot the starvation before parts explode, and what to do about it.

ClickHouse query latency P99 spikes: tail latency, hot shards, and cold data

Diagnose and fix ClickHouse P99 query latency spikes caused by tail latency, hot shards, cold data, and resource contention.

ClickHouse small inserts anti-pattern: why single-row inserts melt the merge pool

Understand how single-row and micro-batch inserts create part accumulation in ClickHouse, the signals that expose the pattern, and the client-side fixes that actually work.

How To Tune ClickHouse Async Inserts: Key Settings

Understand when ClickHouse server-side async insert buffering genuinely reduces part creation versus when it silently relocates too-many-parts risk into an in-memory buffer.

CockroachDB Operations Guides 5 pages

Open the CockroachDB Operations Guides hub

CockroachDB compaction backlog growing: when Pebble can't keep pace with writes

Diagnose a growing Pebble compaction backlog in CockroachDB before it triggers write stalls, and learn how to restore balance between write ingestion and compaction throughput.

CockroachDB detecting hot ranges: per-range QPS, CPU asymmetry, and the Hot Ranges page

How to detect hot ranges in CockroachDB using per-node CPU asymmetry and the DB Console Hot Ranges/Top Ranges page.

CockroachDB Pebble write stalls: when the storage engine refuses writes

Diagnose and resolve CockroachDB Pebble write stalls when the storage engine pauses writes due to LSM compaction debt.

CockroachDB RETRY_WRITE_TOO_OLD: the most common contention restart and how to kill it

Diagnose and eliminate CockroachDB writetooold transaction restarts caused by hot keys, sequential writes, and wide transactions under SERIALIZABLE isolation.

CockroachDB TransactionRetryWithProtoRefreshError: RETRY_SERIALIZABLE causes and fixes

Diagnose and fix CockroachDB RETRY_SERIALIZABLE errors by distinguishing writetooold, readwithinuncertainty, and txnpush causes and implementing proper retry logic.

Elasticsearch Operations Guides 3 pages

Open the Elasticsearch Operations Guides hub

Elasticsearch coordinating node overload: aggregation merge, heap spikes, and 429s

Diagnose and fix Elasticsearch coordinating node overload caused by aggregation merges, heap spikes, and circuit breaker trips that return HTTP 429.

Elasticsearch expensive queries: leading wildcards, regex, deep pagination, and scripts

Find and fix Elasticsearch queries that burn CPU and heap. Covers leading wildcards, regex, deep pagination, scripts, and the diagnostic signals that expose them.

Elasticsearch merge storms: segment explosion, I/O saturation, and refresh tuning

Diagnose and fix Elasticsearch merge storms caused by segment explosion, I/O saturation, and aggressive refresh intervals.

HAProxy Operations Guides 1 page

Open the HAProxy Operations Guides hub

HAProxy kernel accept-queue overflow: silent SYN drops and somaxconn

Clients time out but HAProxy looks perfectly healthy. How to detect and fix Linux accept-queue overflow (ListenOverflows, ListenDrops, somaxconn) in front of HAProxy.

Kafka Operations Guides 1 page

Open the Kafka Operations Guides hub

Kafka NetworkProcessorAvgIdlePercent low: network thread saturation and TLS overhead

Diagnose and fix low NetworkProcessorAvgIdlePercent in Kafka, including network thread saturation from TLS handshakes, connection storms, and large fetch responses.

Microsoft SQL Server Operations Guides 2 pages

Open the Microsoft SQL Server Operations Guides hub

SQL Server CPU utilization high: telling query load apart from a bad plan

SQL Server at 100% CPU is not automatically an incident. Learn how to split SQL Server CPU from other-process CPU, tell legitimate load from a bad plan, and alert on the signals that actually matter.

SQL Server CXPACKET and CXCONSUMER waits: parallelism, MAXDOP, and what is actually wrong

How to read CXPACKET and CXCONSUMER wait stats in SQL Server, when high values are normal, and how to fix the real causes: skewed parallel work, missing indexes, and bad MAXDOP or cost threshold defaults.

MongoDB Operations Guides 8 pages

Open the MongoDB Operations Guides hub

MongoDB cache too small: sizing the WiredTiger cache for your working set

Size the WiredTiger cache to fit your working set. Covers default calculations, explicit overrides, container limits, and the signals that warn you before eviction stalls.

MongoDB exceeded memory limit for $group — aggregation spills and allowDiskUse

Fix MongoDB aggregation pipeline errors when $group or $sort hit the 100MB memory limit, diagnose disk spills, and restructure pipelines for production stability.

MongoDB long-running operations: finding and killing the query holding a ticket

Find and terminate long-running MongoDB operations that are blocking others by holding WiredTiger tickets, using currentOp, killOp, and related diagnostic signals.

MongoDB operation exceeded time limit (MaxTimeMSExpired): maxTimeMS and killed operations

Diagnose MongoDB MaxTimeMSExpired errors. Understand why maxTimeMS kills operations, how to distinguish server-side timeouts from client socket timeouts, and how to find root causes with currentOp and the slow query log.

MongoDB page faults high: working set exceeding memory after warmup

Diagnose and fix sustained high page fault rates in MongoDB when the working set exceeds both WiredTiger cache and OS page cache after warmup.

MongoDB slow query COLLSCAN: collection scans and the missing index

Diagnose and fix MongoDB collection scans (COLLSCAN) that cause slow queries by identifying missing indexes, query plan regressions, and inefficient predicates.

MongoDB ticket exhaustion: WiredTiger read/write tickets and queued operations

Diagnose and fix MongoDB WiredTiger ticket exhaustion when read or write tickets approach zero and operations queue.

MongoDB WiredTiger cache dirty ratio high: the leading indicator nobody watches

Learn why WiredTiger dirty ratio is a stronger leading indicator than cache fill, how to diagnose it before latency spikes, and what to fix.

MySQL Operations Guides 9 pages

Open the MySQL Operations Guides hub

MySQL full table scans: Handler_read_rnd_next and the missing index

Diagnose unexpected full table scans in MySQL by correlating Handler_read_rnd_next step-changes with Slow_queries, then isolate the offending query and fix the index coverage.

MySQL InnoDB history list length growing: purge lag explained

Understand how InnoDB purge lag works, why the history list length grows, and how MVCC read views turn a single idle transaction into fleet-wide slowdown.

MySQL InnoDB redo log checkpoint stall: when all writes freeze

Diagnose and fix InnoDB redo log checkpoint stalls that synchronously freeze all MySQL writes when checkpoint age exceeds redo capacity.

MySQL InnoDB row lock contention: finding who blocks whom

Diagnose InnoDB row lock contention in MySQL 8.0+ and 5.7 by mapping blocking transactions with performance_schema.data_lock_waits, sys.innodb_lock_waits, and the right status metrics.

MySQL innodb_buffer_pool_size tuning: 60-80% of RAM and when that breaks

Operational guide to sizing MySQL's InnoDB buffer pool, the 60-80% RAM heuristic, alignment constraints, and the container and memory gotchas that make it fail.

MySQL innodb_redo_log_capacity sizing: how big should the redo log be

Size the MySQL InnoDB redo log to avoid checkpoint stalls. Covers 8.0.30+ dynamic capacity, headroom calculations, and flush tuning.

MySQL query plan regression: when a query gets slow after a deploy or ANALYZE

Diagnose and fix sudden MySQL query slowdowns caused by bad execution plans after deployments, ANALYZE TABLE, schema changes, or upgrades.

MySQL slow commits with idle CPU: redo and binlog fsync pressure

Diagnose and fix MySQL commit latency when CPU is idle but transactions stall on redo log and binary log fsync pressure.

MySQL slow queries: from Slow_queries to the slow log to the fix

Diagnose MySQL slow queries when Slow_queries climbs, the slow log is disabled, or long_query_time hides real problems. Read-only checks, ratio analysis, and targeted fixes.

NGINX Operations Guides 5 pages

Open the NGINX Operations Guides hub

NGINX active connections climbing: reading, writing, waiting explained

Interpret NGINX stub_status Reading, Writing, and Waiting states to distinguish healthy keepalive reuse from slow clients, slow upstreams, and connection exhaustion.

NGINX Connection Exhaustion: Detection, Diagnosis & Prevention

Detect, diagnose, and prevent NGINX connection exhaustion before it causes cliff-edge timeouts. Covers worker_connections limits, kernel accept queues, keepalive pileup, and upstream slowdown.

NGINX SSL/TLS handshake CPU saturation: detection and tuning

Detect when NGINX workers saturate CPU on TLS handshakes and tune session caching, protocol version, and connection reuse to recover throughput.

NGINX worker_connections & worker_processes: Sizing For Real Traffic

How to size NGINX worker_processes and worker_connections for production traffic, including the reverse-proxy multiplier, FD chain, and headroom rules.

nginx: a client request body is buffered to a temporary file — what it means

Understand why nginx buffers client request bodies to temporary files, how client_body_buffer_size controls the threshold, and when to tune or disable buffering for streaming uploads.

PostgreSQL Operations Guides 7 pages

Open the PostgreSQL Operations Guides hub

PostgreSQL autovacuum tuning: per-table thresholds for high-churn workloads

Configure per-table autovacuum thresholds, memory, and I/O throttling to control bloat and freeze progress on high-churn PostgreSQL tables.

PostgreSQL checkpoint storms: detection, causes, and tuning

Detect and fix PostgreSQL checkpoint storms before they stall your queries. Covers forced vs timed checkpoints, max_wal_size tuning, and safe tuning tradeoffs.

PostgreSQL index bloat: detection and REINDEX CONCURRENTLY recovery

Detect B-tree index bloat in PostgreSQL using pgstatindex and recover online with REINDEX CONCURRENTLY without locking the table.

PostgreSQL missing indexes: detection from pg_stat_statements and logs

Detect missing indexes in PostgreSQL using pg_stat_user_tables, pg_stat_statements, auto_explain, and HypoPG without disrupting production.

PostgreSQL Slow Queries: Diagnosis From Log To Plan To Fix

A practical troubleshooting guide for diagnosing PostgreSQL slow queries using pg_stat_statements, log_min_duration_statement, auto_explain, and execution plan analysis.

PostgreSQL: checkpoints are occurring too frequently -- what to tune

Diagnose and fix frequent PostgreSQL checkpoints. Learn when to raise max_wal_size, adjust checkpoint_timeout, and spread I/O with checkpoint_completion_target.

Reading EXPLAIN ANALYZE: the operator's guide to PostgreSQL query plans

Learn to read PostgreSQL EXPLAIN ANALYZE output like an SRE. Understand actual versus estimated rows, buffer hits, the loops multiplier, and common misreadings that waste tuning effort.

Redis Operations Guides 6 pages

Open the Redis Operations Guides hub

Redis big keys: finding the giant key that blocks the event loop

Diagnose and fix Redis latency caused by oversized keys and O(N) commands blocking the single-threaded event loop.

Redis CPU saturation: hitting the single-core throughput ceiling

Diagnose Redis main-thread CPU saturation. Learn why single-threaded command execution creates a linear latency ramp, which metrics expose it, and how to relieve the bottleneck.

Redis eviction policy tuning: allkeys-lru vs volatile-ttl vs noeviction

How Redis maxmemory eviction policies work, when each policy is the right choice, and how to detect when the wrong policy is causing silent failures or OOM write rejections.

Redis KEYS command blocking production: why to replace it with SCAN

Diagnose and fix Redis production outages caused by the KEYS command blocking the single-threaded event loop, and replace it with SCAN.

Redis latest_fork_usec too high: THP, NUMA, and fork latency

Diagnose and fix elevated Redis fork latency caused by Transparent Huge Pages, NUMA misconfiguration, and memory overcommit issues.

Redis memory pressure spiral: eviction thrashing and how to break it

Diagnose and break the Redis memory pressure spiral where eviction, cache misses, and re-population writes feedback into each other.

VMware vSphere Operations Guides 3 pages

Open the VMware vSphere Operations Guides hub

vSphere CPU co-stop high (%CSTP): the SMP vCPU co-scheduling penalty

Diagnose high %CSTP on multi-vCPU VMs: vCPU oversizing, NUMA boundary crossing, snapshot-induced co-stop, and the relaxed co-scheduling trap that makes any visible value more severe than it looks.

vSphere CPU limit hit (%MLMTD): the forgotten MHz cap that silently throttles a VM

How to diagnose and fix CPU limit throttling (%MLMTD) in vSphere, where a set-and-forgotten MHz cap silently degrades VMs that look healthy on ready time.

vSphere CPU ready time high (%RDY): VMs starved while the guest looks idle

Diagnose and fix high CPU ready time in vSphere, where VMs are starved for pCPU time while guest OS CPU utilization appears low.

Academy

Docker Layer Caching in CI Pipelines Cut Build Times by 70 %

A practical guide to using docker buildx- multi-stage builds- and remote cache backends for lightning-fast container builds

PostgreSQL 17 Cardinality Estimation & Tuning Tips

A deep dive into how the query planner thinks and how to leverage new features for smarter- faster queries

Using FOR UPDATE SKIP LOCKED For Queue Workflows

How a single SQL clause can transform your database into a high-throughput- parallel-processing task queue

Fix NGINX 503 Errors From Misconfigured limit_req

A deep dive into tuning NGINX rate limits to protect your origin without accidentally rejecting legitimate users

Linux Load Average Spikes: IO Wait & Bottlenecks

Learn to interpret load average correctly and use tools like iostat and vmstat to find the root cause of system performance issues

Buffering keepalive and Hidden 500-Series Errors in NGINX

A deep dive into nginx buffering keepalive timeouts and how they can silently trigger 500 502 and 504 errors in your infrastructure

Apache Kafka Consumer Lag: Troubleshooting & Fixes

A deep dive into the causes of consumer lag- how to monitor it- and how to tune your Kafka consumers for optimal performance

25 NGINX Directives to Audit Before Opening a Support Ticket

A practical checklist to help you find and fix common NGINX issues yourself

Short vs Long Transactions In PostgreSQL Benchmarks

How holding locks for milliseconds longer can cripple your database- and how to prove it with a repeatable benchmark

Garbage Collection In Java What It Is and How It Works

Understanding the automatic memory management that powers the JVM

Nodejs Memory Leak How To Identify Debug And Avoid Them

A deep dive into Nodejs memory management- common leak causes- detection tools- and proactive strategies to keep your applications running smoothly.

A Comprehensive Guide To Database Performance Optimization

Unlock peak database efficiency and reliability with proven strategies for performance tuning and optimization- Say goodbye to bottlenecks and hello to speed.

Normalized vs Denormalized - Choosing The Right Data Model

Balancing data integrity and query performance in database design

Ecommerce Infrastructure: Components & Benefits

The essential technical foundation for building and scaling online stores

Analyze & Reduce Disk I/O Bottlenecks: Top Techniques

Mastering Disk Performance for Optimal System Health

High CPU Usage Detected How To Fix CPU Overload

A step-by-step guide for developers and SREs to troubleshoot and resolve CPU performance bottlenecks

How to Troubleshoot Slow Queries in MongoDB

A Beginner’s Guide to Optimizing MongoDB Performance

How To Speed Up Windows 10 & 11: Performance Tips

Essential Tweaks To Boost Your Windows PC

What Is Cardinality In Databases: A Comprehensive Guide

Why Cardinality Is Key To Database Performance

What Is Continuous Profiling & Why It Matters

A Beginner's Guide to Understanding and Implementing Continuous Profiling in Your Software Monitoring Strategy

MySQL Monitoring

Learn everything about monitoring & troubleshooting MySQL, what metrics are important to monitor and why, and how to monitor MySQL with Netdata.

PHP-FPM Monitoring

Learn everything about monitoring & troubleshooting PHP-FPM, what metrics are important to monitor and why, and how to monitor PHP-FPM with Netdata.

PostgreSQL Monitoring

Find out about monitoring & troubleshooting PostgreSQL, what metrics are important to monitor and why, and how to monitor PostgreSQL with Netdata.

Case Studies

Streamlining IT Operations with Netdata

Simplifying Complex Monitoring for a Hybrid Infrastructure

Transforming critical software development

Enhanced observability and real time metric correlation

Resources

Webinar: Kubernetes Throttling? It Doesn't Have to Suck!

See how Kubernetes CPU throttling impacts your workloads — and how to monitor, troubleshoot, and fix it. Includes a live stress test of a K8s cluster with real results.