Short answer: do not guess. To find out why a SQL Server is slow, define what “slow” means and when it started, check what changed, look for resource pressure, read wait statistics, find the worst queries, check blocking, storage latency, statistics and indexes, and review configuration, changing one thing at a time and measuring each change. The ten steps below, with queries you can run today, find the cause in most cases.
Updated October 13, 2026. Written by Nathan Jaskot, founder of Everconnect Data Systems, a US-based, veteran-owned database consulting firm founded in 2010. Technical facts were checked against Microsoft documentation on that date (sources at the bottom).
At a glance
- Start with facts: which queries, which users, which times, compared to when.
- Waits tell you what SQL Server is waiting for; queries tell you who is asking.
- Most slowdowns come from a short list: blocking, a few expensive queries, stale statistics or plan changes, slow storage, and configuration drift.
- One change at a time, with before-and-after measurements.
The 10-step triage
1. Define “slow”
Write down which screen, report or job is slow, for whom, at what times, how slow compared with normal, and when it started. A vague complaint cannot be fixed; a specific one usually points at a specific query.
2. Ask what changed
Data growth, a new release, a patch, a configuration change, a new report, a changed schedule, a moved virtual machine or storage change. Many slowdowns line up with a change; check deployment and change records first.
3. Check resource pressure
Look at CPU, memory and disk on the server during the slow period. Sustained high CPU, low free memory or long disk queues point you toward the next steps; normal resources push you toward blocking or a single bad query.
4. Read the wait statistics
SQL Server records what sessions wait on. The top waits suggest the bottleneck (for example I/O, locking, parallelism, memory grants). The numbers are cumulative since the last restart or clear, so compare over time. See Microsoft’s sys.dm_os_wait_stats documentation.
-- Top waits since the last restart (filters a few benign background waits)
SELECT TOP (10)
wait_type,
wait_time_ms / 1000.0 AS wait_seconds,
signal_wait_time_ms / 1000.0 AS signal_seconds,
waiting_tasks_count
FROM sys.dm_os_wait_stats
WHERE waiting_tasks_count > 0
AND wait_type NOT IN (N'SLEEP_TASK', N'LAZYWRITER_SLEEP', N'XE_TIMER_EVENT', N'XE_DISPATCHER_WAIT',
N'REQUEST_FOR_DEADLOCK_SEARCH', N'SQLTRACE_INCREMENTAL_FLUSH_SLEEP', N'BROKER_TO_FLUSH',
N'BROKER_TASK_STOP', N'CLR_AUTO_EVENT', N'DISPATCHER_QUEUE_SEMAPHORE', N'FT_IFTS_SCHEDULER_IDLE_WAIT',
N'DIRTY_PAGE_POLL', N'CHECKPOINT_QUEUE', N'WAITFOR', N'LOGMGR_QUEUE', N'SP_SERVER_DIAGNOSTICS_SLEEP')
ORDER BY wait_time_ms DESC;
5. Find the worst queries
If Query Store is on, use its top resource consuming queries reports. Otherwise the plan cache gives a rough view (it resets on restart and can be evicted).
-- Top 10 statements by total CPU from the plan cache
SELECT TOP (10)
qs.execution_count,
qs.total_worker_time / qs.execution_count AS avg_cpu_microseconds,
qs.total_elapsed_time / qs.execution_count AS avg_elapsed_microseconds,
SUBSTRING(st.text, (qs.statement_start_offset / 2) + 1,
((CASE qs.statement_end_offset WHEN -1 THEN DATALENGTH(st.text)
ELSE qs.statement_end_offset END - qs.statement_start_offset) / 2) + 1) AS statement_text
FROM sys.dm_exec_query_stats AS qs
CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) AS st
ORDER BY qs.total_worker_time DESC;
6. Check blocking
A query that is waiting on another session’s locks looks slow but is not working. See our deeper guide to identifying and fixing blocking issues.
-- Who is blocked, and by whom, right now
SELECT r.session_id, r.blocking_session_id, r.wait_type, r.wait_time AS wait_ms,
DB_NAME(r.database_id) AS database_name, t.text AS sql_text
FROM sys.dm_exec_requests AS r
CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) AS t
WHERE r.blocking_session_id <> 0;
7. Measure storage latency
Slow reads and writes at the file level slow everything. Compare average latency per file; consistently high values mean the storage layer, not the query, is the first thing to look at.
-- Average read and write latency per database file since the last restart
SELECT DB_NAME(vfs.database_id) AS database_name, mf.physical_name,
vfs.io_stall_read_ms / NULLIF(vfs.num_of_reads, 0) AS avg_read_ms,
vfs.io_stall_write_ms / NULLIF(vfs.num_of_writes, 0) AS avg_write_ms
FROM sys.dm_io_virtual_file_stats(NULL, NULL) AS vfs
JOIN sys.master_files AS mf
ON vfs.database_id = mf.database_id AND vfs.file_id = mf.file_id
ORDER BY avg_read_ms DESC;
8. Review statistics and indexes
Stale or missing statistics lead to poor plans, and missing or unused indexes cost reads and writes. Treat missing-index suggestions as hints, not instructions: validate each against the workload before creating it. See our post on missing indexes and Microsoft’s statistics documentation.
9. Look for plan changes and parameter sensitivity
A query that was fast and suddenly is not often got a different plan, for example after a statistics update, a parameter value or a version change. Query Store shows plan history per query so you can compare and, if appropriate, force the better plan while you fix the cause. See how to diagnose slow stored procedures.
10. Check configuration and tempdb
Review max server memory, max degree of parallelism and the cost threshold for parallelism, and tempdb file layout. Misconfiguration is common after hardware or virtualization changes. Microsoft documents server memory, max degree of parallelism and tempdb.
When to call a specialist
Call one when slowdowns are causing outages, when the evidence points to several causes at once, when the vendor and your team disagree on the cause (see what to do when the vendor blames SQL Server), or when nobody has reviewed the environment in years. Everconnect Data Systems offers database performance tuning; you can also start with the free SQL Server Health & Risk Check (a self-assessment, no database access required).
Want a fixed-price starting point? The SQL Server Health Check is $499 per server: about 200 read-only checks across 10 risk areas, a scored report in 3 business days and a walkthrough with our team. See an example report.
Frequently asked questions
Define what is slow and when it started, check what changed, look at CPU, memory and disk, read wait statistics, find the worst queries, check blocking and storage latency, review statistics, indexes and plans, then review configuration. Change one thing at a time and measure.
A record of what sessions have waited on, such as disk I/O, locks, parallelism or memory grants. The top waits point to the bottleneck, but they are cumulative since the last restart or clear, so compare over time.
There is no single cause, but a short list explains most cases: blocking, a few expensive queries, stale statistics or changed plans, slow storage and configuration problems.
Use Query Store if it is enabled, or query the plan cache with sys.dm_exec_query_stats for the highest CPU, duration or read counts. Plan cache data resets on restart.
Query sys.dm_exec_requests for sessions with a non-zero blocking_session_id, or look for lock waits in the wait statistics. A blocked query looks slow but is waiting, not working.
Use sys.dm_io_virtual_file_stats to see average read and write latency per database file, and compare with your storage expectations. Consistently high latency points to the storage layer.
Yes, but treat missing-index suggestions as hints and validate each against the workload before creating one, because every index costs writes and storage.
SQL Server builds a plan using the parameter values from the first execution, which can be a poor fit for later values. Query Store helps you see and, if appropriate, force a better plan while you fix the cause.
When slowdowns cause outages, when several causes overlap, when the application vendor and your team disagree on the cause, or when the environment has not been reviewed in years.
Related guides
- SQL Server without a DBA: minimum maintenance checklist
- Vendor blames SQL Server? How to verify independently
- The ultimate SQL Server health checklist
- How to identify and fix blocking issues in SQL Server
- How to diagnose slow stored procedures
- Independent SQL Server assessment: what a good one covers
Sources (checked October 13, 2026)
- sys.dm_os_wait_stats
- sys.dm_io_virtual_file_stats
- sys.dm_exec_requests
- sys.dm_exec_query_stats
- Monitoring performance by using the Query Store
- Statistics (Microsoft Learn)
- Server memory configuration options
- Configure the max degree of parallelism option
- tempdb database
- Intelligent query processing
About the author. Nathan Jaskot is the founder of Everconnect Data Systems, Inc., a US-based, veteran-owned database and technology consulting company he started in 2010. Everconnect works with SQL Server, PostgreSQL, MySQL, Oracle, Azure and AWS. Learn more about Everconnect.




