{"id":5370,"date":"2026-03-25T13:11:58","date_gmt":"2026-03-25T20:11:58","guid":{"rendered":"https:\/\/www.sqlskills.com\/blogs\/paul\/?p=5370"},"modified":"2026-03-25T15:34:14","modified_gmt":"2026-03-25T22:34:14","slug":"sql101-top-ten-sql-server-performance-tuning-best-practices","status":"publish","type":"post","link":"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/","title":{"rendered":"SQL101: Top Ten SQL Server Performance Tuning Best Practices"},"content":{"rendered":"<p style=\"text-align: justify;\">There are a huge number of best practices around SQL Server performance tuning \u2013 I could easily write a whole book on the topic, especially when you consider the number of different database settings, server settings, coding practices, wait types, and so on that can affect performance. For this post I decided to step back a bit from a list of specifics and list some general recommendations for how to <em>approach<\/em> performance tuning so that you maximize effort and minimize distractions.<\/p>\n<h3 style=\"text-align: justify;\">1) Don\u2019t Assume the Symptom Is the Root Cause<\/h3>\n<p style=\"text-align: justify;\">Many DBAs and developers tend towards what I call \u2018knee-jerk performance troubleshooting\u2019, where a minimal amount of analysis and investigation is performed and the assumption is made that the most prevalent symptom of poor performance must be the root cause. When this happens, and effort is made to try to address the supposed root cause, it can lead to a lot of wasted time, and frustration that the mitigation efforts don\u2019t help the situation.<\/p>\n<p style=\"text-align: justify;\">My favorite example of this, and a problem I\u2019m sure you\u2019ve all had, is when \u00a0average disk latency is high. The classic knee-jerk reaction is that it must be the I\/O subsystem that has a problem, so the company spends money on a better I\/O subsystem and the problem goes away for a little while and then comes back again, because the problem is not the hardware itself, but something happening within SQL Server.<\/p>\n<p style=\"text-align: justify;\">For a case like this, it\u2019s generally better to take a mental step back and ask why is SQL Server overloading the I\/O subsystem or more precisely, why is SQL Server doing so many physical reads. There are many reasons this could be happening, such as (but not limited to):<\/p>\n<ul style=\"text-align: justify;\">\n<li>An inefficient query plan doing a large, parallel table scan instead of using a nonclustered index because of something like a missing index, or implicit conversion, or out-of-date statistics<\/li>\n<li>Memory pressure on the buffer pool (meaning there isn\u2019t enough space to hold the usual \u2018working set\u2019 of database pages) from the OS<\/li>\n<\/ul>\n<p style=\"text-align: justify;\">It always pays to do some investigation instead of jumping to a quick conclusion on the root cause.<\/p>\n<h3 style=\"text-align: justify;\">2) Determine the Scope of the Problem<\/h3>\n<p style=\"text-align: justify;\">It\u2019s extremely important to figure out what the scope of the problem is, as that determines how you\u2019ll go about investigating the problem, what metrics to gather, and what scripts and tools to use. For instance, being asked to investigate stored procedure XYZ which takes twice as long to run as it usually does is very different from being asked to tune all long-running stored procedures.<\/p>\n<p style=\"text-align: justify;\">Stored procedure metrics can be obtained by running the query in Management Studio, and noting duration, CPU, and IO statistics.\u00a0 That information can also be obtained from the plan cache, and you can also leverage the plan cache when you need to find the longest-running stored procedures.\u00a0 The following query, adapted from the popular set of DMV scripts <a href=\"https:\/\/glennsqlperformance.com\/resources\/\">here<\/a>, lists the slowest 25 procedures, based on average duration:<\/p>\n<pre class=\"brush: sql; title: ; toolbar: true; wrap-lines: true; notranslate\" title=\"\">\r\nSELECT\r\n    TOP (25) &#x5B;p].&#x5B;name] AS &#x5B;SP Name],\r\n    &#x5B;eps].&#x5B;min_elapsed_time],\r\n    &#x5B;eps].&#x5B;total_elapsed_time] \/ &#x5B;eps].&#x5B;execution_count] AS &#x5B;avg_elapsed_time],\r\n    &#x5B;eps].&#x5B;max_elapsed_time],\r\n    &#x5B;eps].&#x5B;last_elapsed_time],\r\n    &#x5B;eps].&#x5B;total_elapsed_time],\r\n    &#x5B;eps].&#x5B;execution_count],\r\n    ISNULL (&#x5B;eps].&#x5B;execution_count] \/\r\n        DATEDIFF (MINUTE, &#x5B;eps].&#x5B;cached_time], GETDATE ()), 0) AS &#x5B;Executions\/Minute],\r\n    FORMAT (&#x5B;eps].&#x5B;last_execution_time],\r\n        &#039;yyyy-MM-dd HH:mm:ss&#039;, &#039;en-US&#039;) AS &#x5B;Last Execution Time],\r\n    FORMAT (&#x5B;eps].&#x5B;cached_time],\r\n        &#039;yyyy-MM-dd HH:mm:ss&#039;, &#039;en-US&#039;) AS &#x5B;Plan Cached Time]\r\n    -- ,&#x5B;qp].&#x5B;query_plan] AS &#x5B;Query Plan] -- Uncomment if you want the query plan\r\nFROM sys.procedures AS &#x5B;p] WITH (NOLOCK)\r\nINNER JOIN sys.dm_exec_procedure_stats AS &#x5B;eps] WITH (NOLOCK)\r\n    ON &#x5B;p].&#x5B;object_id] = &#x5B;eps].&#x5B;object_id]\r\nCROSS APPLY sys.dm_exec_query_plan (&#x5B;eps]. &#x5B;plan_handle]) AS &#x5B;qp]\r\nWHERE\r\n    &#x5B;eps].&#x5B;database_id] = DB_ID ()\r\n    AND DATEDIFF (MINUTE, &#x5B;eps].&#x5B;cached_time], GETDATE()) &gt; 0\r\nORDER BY &#x5B;avg_elapsed_time] DESC\r\nOPTION (RECOMPILE);\r\n<\/pre>\n<p style=\"text-align: justify;\">There are also tools like the <a href=\"https:\/\/www.sentryone.com\/products\/features\/top-sql\">Top SQL functionality<\/a> in SolarWinds SQL Sentry that can help identify highest impact and highest resource using queries.<\/p>\n<h3 style=\"text-align: justify;\">3) Define the Goal for Success<\/h3>\n<p style=\"text-align: justify;\">Once you have the scope of the problem, the next step is to determine the goal of the performance tuning effort, so you know when you&#8217;ve achieved success and can move on to another task. Don\u2019t allow the goal to be something undefined and open-ended like \u2018stored procedure XYZ needs to be faster\u2019, it needs to be well-defined such as \u2018stored procedure XYZ needs to run at the speed it did before, i.e. at 50% of the current elapsed time\u2019.<\/p>\n<p style=\"text-align: justify;\">Sometimes the investigation will be a bit more involved if the scope is wider, requiring capturing metrics and information over time before any analysis and mitigation can start. For instance, one of the first consulting clients I worked with had a somewhat open-ended goal for me which was, paraphrasing, \u2018tempdb runs out of space once a week, and we need it not to do that\u2019 without any idea why. The investigation involved me setting up two SQL Agent jobs; one every 10 seconds to look for large uses of tempdb and log information to a table, and another once an hour to email me any results from the previous hour. The general code I wrote to find space-hogs in tempdb is below:<\/p>\n<pre class=\"brush: sql; title: ; toolbar: true; wrap-lines: true; notranslate\" title=\"\">\r\n-- InternalMB\/Pages: worktables (cursor, spool) , workfiles (hash joins), sort\r\n-- UserMB\/Pages: everything else\r\n--\r\nSELECT\r\n    GETDATE () AS &#x5B;Date],\r\n    &#x5B;tsu].&#x5B;session_id] AS &#x5B;SessionID],\r\n    &#x5B;tsu].&#x5B;exec_context_id] AS &#x5B;ExecContextID], -- anything over 0 means parallelism\r\n    (&#x5B;tsu].&#x5B;user_objects_alloc_page_count] -\r\n        &#x5B;tsu].&#x5B;user_objects_dealloc_page_count]) AS &#x5B;UserPages],\r\n    ROUND (CONVERT (FLOAT, (&#x5B;tsu].&#x5B;user_objects_alloc_page_count] -\r\n        &#x5B;tsu].&#x5B;user_objects_dealloc_page_count]) * 8) \/ 1024.0, 2) AS &#x5B;UserMB],\r\n    (&#x5B;tsu].&#x5B;internal_objects_alloc_page_count] -\r\n        &#x5B;tsu].&#x5B;internal_objects_dealloc_page_count]) AS &#x5B;InternalPages],\r\n    ROUND (CONVERT (FLOAT, (&#x5B;tsu].&#x5B;internal_objects_alloc_page_count] -\r\n        &#x5B;tsu].&#x5B;internal_objects_dealloc_page_count]) * 8) \/ 1024.0, 2) AS &#x5B;InternalMB],\r\n    &#x5B;er].&#x5B;plan_handle] AS &#x5B;Plan],\r\n    &#x5B;est].&#x5B;text] AS &#x5B;Text]\r\nFROM sys.dm_db_task_space_usage &#x5B;tsu]\r\nJOIN sys.dm_exec_requests &#x5B;er]\r\n    ON &#x5B;er].&#x5B;session_id] = &#x5B;tsu].&#x5B;session_id]\r\nCROSS APPLY sys.dm_exec_sql_text (&#x5B;er].&#x5B;sql_handle]) &#x5B;est]\r\n\/*\r\nWHERE\r\n    -- Optionally, filter by a size limit\r\n    -- E.g., the 16384 is 128MB in 8KB pages\r\n    ((&#x5B;user_objects_alloc_page_count] - &#x5B;user_objects_dealloc_page_count]) +\r\n        (&#x5B;internal_objects_alloc_page_count] - &#x5B;internal_objects_dealloc_page_count])) &gt;= 16384\r\n*\/\r\nORDER BY\r\n    ((&#x5B;user_objects_alloc_page_count] - &#x5B;user_objects_dealloc_page_count]) +\r\n        (&#x5B;internal_objects_alloc_page_count] - &#x5B;internal_objects_dealloc_page_count])) DESC;\r\n<\/pre>\n<h3>4) Understand the Limitations<\/h3>\n<p style=\"text-align: justify;\">Before you start proposing or making changes, it\u2019s important to know if there are any things you simply cannot do. Here are some examples:<\/p>\n<ul style=\"text-align: justify;\">\n<li>If the application is written by a vendor, you\u2019re not going to be able to make code changes to improve performance<\/li>\n<li>If the application is written by a vendor, you might not even be able to add or change indexes without voiding the vendor\u2019s support agreement<\/li>\n<li>You might not be able to change a setting like MAXDOP or parameter sniffing for the whole server, which may mean using an <a href=\"https:\/\/docs.microsoft.com\/en-us\/sql\/t-sql\/statements\/alter-database-scoped-configuration-transact-sql\">ALTER DATABASE SCOPED CONFIGURATION<\/a> option for just one database<\/li>\n<\/ul>\n<p style=\"text-align: justify;\">Even if you can change code, there may be a lengthy testing process which prevents a change from being immediately implemented, so you may need to pursue alternative solutions (potentially short-term) to quickly fix the problem.<\/p>\n<h3 style=\"text-align: justify;\">5) Change One Thing at a Time<\/h3>\n<p style=\"text-align: justify;\">One of the most confusing things to do when performance tuning is to make multiple changes at the same time, as then you won\u2019t know which change had an effect, or whether multiple changes cancelled each other out. Always change one thing at a time and keep a note of what you changed and what effect it had, if any. Also, if a change doesn\u2019t have any effect then revert the change so that it doesn\u2019t become a complication if the workload evolves at a later date.<\/p>\n<h3>6) Do Not Test in Production<\/h3>\n<p style=\"text-align: justify;\">One of the worst things to do when performance tuning is to make changes directly in production, as that can lead to dire consequences for the workload and business if a change create a huge negative effect. This means you need a separate test\/QA environment that can be used to evaluate changes under production workload conditions, or as close to it as possible. And that leads nicely into the next point\u2026<\/p>\n<h3 style=\"text-align: justify;\">7) Understand How Test Compares to Production<\/h3>\n<p style=\"text-align: justify;\">If your test system doesn\u2019t compare to production then you may not see the same change in performance in production as you do in test. Classic examples of this include:<\/p>\n<ul style=\"text-align: justify;\">\n<li>A production system with a certain number of CPUs (e.g. four 8-core processors) and a lower powered test system to save money (e.g. four quad-core processors)<\/li>\n<li>Along the same lines, test system having a lot less memory than production, or a different NUMA configuration, or a lower-rated storage subsystem<\/li>\n<li>Test system only having a subset of the production data to test with<\/li>\n<li>Test system not being able to simulate the production workload<\/li>\n<\/ul>\n<p style=\"text-align: justify;\">All of these things can result in the test system producing different query plans, or the workload in test having very different characteristics than in production. This means you\u2019ll be performance tuning for a different workload and environment and the efficacy of the changes may not translate to the production environment.<\/p>\n<h3>8) Understand the Implications of the Change<\/h3>\n<p style=\"text-align: justify;\">After you\u2019ve determined what the necessary change is, you need to consider what wider effect, if any, making that change will have. For example, if you need to change MAXDOP or the cost threshold for parallelism, that will flush the plan cache, and you might run the risk of parameter-sensitive queries recompiling with sub-optimal plans.<\/p>\n<p style=\"text-align: justify;\">Other changes might be more environmental, like offloading parts of a query workload to a readable secondary in an availability group. That can lead to index fragmentation issues on the primary database, which can be a performance problem of their own (as I described in <a href=\"https:\/\/sqlperformance.com\/2015\/03\/sql-indexes\/unexpected-fragmentation\">this SQLPerformance.com post<\/a>).<\/p>\n<p style=\"text-align: justify;\">You don\u2019t want to solve one performance problem and end up with an unexpected different problem to then have to solve.<\/p>\n<h3>9) Create a Rollback Plan<\/h3>\n<p style=\"text-align: justify;\">It\u2019s very important that you have a complete log of what\u2019s been changed and have the ability to revert the changes if something goes wrong. This means preserving original copies of all code and schema and ideally having a script you can run to quickly roll back the changes.<\/p>\n<p style=\"text-align: justify;\">If this would be hard to do, and would really entail restoring the database from backups, one thing to consider is creating a database snapshot of the database and keeping it around for a few days. A database snapshot automatically keeps a pre-change copy of all changed data file pages since the time the database snapshot was created and allows you to effectively put the database back to that time with a one-line T-SQL command (internally SQL Server does this by pushing the pre-change pages back into the real database \u2013 called \u2018reverting the database to the database snapshot\u2019).<\/p>\n<h3 style=\"text-align: justify;\">10) Remove Diagnostic Elements from Production<\/h3>\n<p style=\"text-align: justify;\">Once you\u2019ve finished the investigation and reached the performance tuning goal, make sure you remove all of the diagnostics that you implemented to help with the investigation, as they could cause performance problems themselves if left in place, especially Extended Event sessions as they can become \u2018silent killers\u2019 that use up a lot of CPU resources with no other clue that they are the problem.<\/p>\n<p style=\"text-align: justify;\">You can see which Extended Event sessions are running using the following code:<\/p>\n<pre class=\"brush: sql; title: ; toolbar: true; wrap-lines: true; notranslate\" title=\"\">\r\nSELECT\r\n    &#x5B;ses].&#x5B;name] AS &#x5B;Session Name],\r\n    CASE\r\n        WHEN &#x5B;xs].&#x5B;address] IS NOT NULL THEN &#039;Running&#039;\r\n        ELSE &#039;Stopped&#039;\r\n    END AS &#x5B;State],\r\n    &#x5B;xs].&#x5B;create_time] AS &#x5B;Start Time]\r\nFROM sys.server_event_sessions AS &#x5B;ses]\r\nLEFT OUTER JOIN sys.dm_xe_sessions AS &#x5B;xs]\r\n    ON &#x5B;ses].&#x5B;name] = &#x5B;xs].&#x5B;name]\r\nORDER BY &#x5B;State], &#x5B;Start Time];\r\n<\/pre>\n<p style=\"text-align: justify;\">And if you&#8217;re on SQL Server 2025 and using Extended Events, there&#8217;s a new MAX_DURATION option you can use to ensure a diagnostic session stops running after a certain amount of time.<\/p>\n<h2>Summary<\/h2>\n<p>You should always take a step-by-step approach to performance tuning rather than jumping right in and changing things haphazardly in production, and I hope this post has provided you with a simple framework you can put into practice. There\u2019s a lot of code out there to help you with various investigations, plus free tools like <a href=\"https:\/\/www.solarwinds.com\/free-tools\/plan-explorer\" target=\"_blank\" rel=\"noopener\">Plan Explorer<\/a> \u2013 I can\u2019t recommend this enough!\u00a0Happy tuning!<\/p>\n","protected":false},"excerpt":{"rendered":"<p>There are a huge number of best practices around SQL Server performance tuning \u2013 I could easily write a whole book on the topic, especially when you consider the number of different database settings, server settings, coding practices, wait types, and so on that can affect performance. For this post I decided to step back [&hellip;]<\/p>\n","protected":false},"author":5,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[66,108],"tags":[],"class_list":["post-5370","post","type-post","status-publish","format-standard","hentry","category-performance-tuning","category-sql101"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v26.5 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>SQL101: Top Ten SQL Server Performance Tuning Best Practices - Paul S. Randal<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"SQL101: Top Ten SQL Server Performance Tuning Best Practices - Paul S. Randal\" \/>\n<meta property=\"og:description\" content=\"There are a huge number of best practices around SQL Server performance tuning \u2013 I could easily write a whole book on the topic, especially when you consider the number of different database settings, server settings, coding practices, wait types, and so on that can affect performance. For this post I decided to step back [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/\" \/>\n<meta property=\"og:site_name\" content=\"Paul S. Randal\" \/>\n<meta property=\"article:published_time\" content=\"2026-03-25T20:11:58+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-03-25T22:34:14+00:00\" \/>\n<meta name=\"author\" content=\"Paul Randal\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Paul Randal\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/\",\"name\":\"SQL101: Top Ten SQL Server Performance Tuning Best Practices - Paul S. Randal\",\"isPartOf\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#website\"},\"datePublished\":\"2026-03-25T20:11:58+00:00\",\"dateModified\":\"2026-03-25T22:34:14+00:00\",\"author\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce\"},\"breadcrumb\":{\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"SQL101: Top Ten SQL Server Performance Tuning Best Practices\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#website\",\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/\",\"name\":\"Paul S. Randal\",\"description\":\"In Recovery...\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce\",\"name\":\"Paul Randal\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g\",\"caption\":\"Paul Randal\"},\"sameAs\":[\"http:\/\/3.209.169.194\/blogs\/paul\"],\"url\":\"https:\/\/www.sqlskills.com\/blogs\/paul\/author\/paul\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"SQL101: Top Ten SQL Server Performance Tuning Best Practices - Paul S. Randal","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/","og_locale":"en_US","og_type":"article","og_title":"SQL101: Top Ten SQL Server Performance Tuning Best Practices - Paul S. Randal","og_description":"There are a huge number of best practices around SQL Server performance tuning \u2013 I could easily write a whole book on the topic, especially when you consider the number of different database settings, server settings, coding practices, wait types, and so on that can affect performance. For this post I decided to step back [&hellip;]","og_url":"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/","og_site_name":"Paul S. Randal","article_published_time":"2026-03-25T20:11:58+00:00","article_modified_time":"2026-03-25T22:34:14+00:00","author":"Paul Randal","twitter_misc":{"Written by":"Paul Randal","Est. reading time":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/","url":"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/","name":"SQL101: Top Ten SQL Server Performance Tuning Best Practices - Paul S. Randal","isPartOf":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#website"},"datePublished":"2026-03-25T20:11:58+00:00","dateModified":"2026-03-25T22:34:14+00:00","author":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce"},"breadcrumb":{"@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/sql101-top-ten-sql-server-performance-tuning-best-practices\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.sqlskills.com\/blogs\/paul\/"},{"@type":"ListItem","position":2,"name":"SQL101: Top Ten SQL Server Performance Tuning Best Practices"}]},{"@type":"WebSite","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#website","url":"https:\/\/www.sqlskills.com\/blogs\/paul\/","name":"Paul S. Randal","description":"In Recovery...","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.sqlskills.com\/blogs\/paul\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/ffcec826c18782e1e0adf173826a7fce","name":"Paul Randal","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.sqlskills.com\/blogs\/paul\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/0b6a266bba2f088f2551ef529293001bd73bf026bc1908b9866728c062beeeb6?s=96&d=mm&r=g","caption":"Paul Randal"},"sameAs":["http:\/\/3.209.169.194\/blogs\/paul"],"url":"https:\/\/www.sqlskills.com\/blogs\/paul\/author\/paul\/"}]}},"_links":{"self":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts\/5370","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/comments?post=5370"}],"version-history":[{"count":0,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/posts\/5370\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/media?parent=5370"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/categories?post=5370"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.sqlskills.com\/blogs\/paul\/wp-json\/wp\/v2\/tags?post=5370"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}