Prefer another language? Prefere receber em português? ¿Prefieres recibirlo en español? Choose here / Escolha aqui / Elige aquí.

Someone told me: "Parallel redo in SQL Server is always faster than serial redo." I built a lab to check it. After 80 measured runs, I found one scenario where serial was faster, every single time.
In short
One test run doesn't give you enough ground for an opinion. My redo lab took 80 runs, 13 scenarios and 27.5 hours.
Serial redo beat parallel in one case only: hot-tail inserts on Ultra Disk, 6 of 6 tests. The environment made the difference, not a bug.
For DBAs starting out, careful testing protects your credibility.
This tip is not really about redo. It does two things. First, it shows how many runs it took before my lab could say something. Second, it shows why that matters for your credibility, mainly if you are starting your career.
How many test runs do you need before you trust a result?
Monday's post came from a real lab. It's one of many labs I build, each with one goal, one configuration, and enough runs to reach a solid conclusion.
My first round had 12 runs. Every one ended in a tie. Redo finished within a few seconds of the workload, so redo was never the bottleneck. If I had stopped there, I would have said "there's no difference". That would have been wrong.
I only found the real differences when I changed the method. I paused the secondary, built a backlog, and timed how long each mode took to catch up.
I'm not saying my conclusion is the absolute truth. Even after many rounds, a result can still be inconclusive. Most scenarios had only two tests per mode. The secondary had only 8 vCPUs and 4 redo workers. And the lab ran on SQL Server vNext CTP 1.2 on Linux, a pre-release build. But I tested everything I needed for that question, at that moment.
Why was serial redo faster than parallel redo in one case?
The request that came to me was to confirm that parallel redo always wins. In most scenarios it did, or it tied. With random-key inserts on Standard HDD, parallel was 4.5 to 6.2 times faster.
But with hot-tail inserts on Ultra Disk, serial won all six tests: 42 to 52 seconds, against 61 to 72 seconds for parallel. Now look at this: the same scenario on Standard HDD was a tie. Same product, same workload. A different disk.
SQL Server itself didn't have a problem. When the variables of the environment change, a product can behave differently. It shouldn't always happen, but it can. We are now looking at this case internally, in more detail.
⚠️ Don't switch redo modes on a busy server to test this. Serial redo is turned on with trace flag 3459 (SQL Server 2016 and later). It is global: it changes redo for every availability group database on the instance. Test it only in a lab, never in production.
Attio is the #1 fastest-growing CRM on Brex and Ramp
Built for the most ambitious companies in GTM, Attio is an end to end revenue platform that allows teams to run multiple plays across different revenue motions and lifecycles.
Teams at the frontier are already building on it: Granola, turbopuffer, Modal, and many many more.
Why is the root cause often far from where you look?
My first guess was that the redo workers were blocking each other. The data said no. Waits between workers were 8 seconds or less per test.
The real cause was somewhere else: the main redo thread. In parallel mode, this thread reads the log and hands the records to the workers.
Think of a kitchen. One person reads the orders and hands them to the cooks. If each dish takes seconds to make, the cooks wait, and the person handing out orders becomes the slow part.
That's what happened. With hot-tail inserts, each record is small, and its page is already in memory. Applying it is cheap. The hand-off becomes the expensive part. In parallel mode, the main thread used about 30% more CPU per MB. The workers sat idle for 240 to 285 seconds per test, waiting for work.
Many times we know a problem is happening, and we look for the cause in the wrong place. Testing with patience doesn't only confirm what you think. It shows you places you didn't think to look.
How does a quick opinion hurt a junior DBA's credibility?
In Brazil we have a word for this: achismo, an opinion based only on "I think". Every DBA has heard it on a long incident call.
If you are starting your career, be careful with it. When you give an opinion or analyze a problem, make sure it stands on something solid. A shallow opinion will be questioned. When it's questioned and it falls, it can scratch your reputation. That's bad at any career stage, and dangerous at the start.
A fast opinion can work against you. A tested one builds your credibility, one problem at a time.
Your next step: measure your redo baseline more than once
If you have an availability group, open sys.dm_hadr_database_replica_states for one secondary database. Look at two columns: redo_queue_size (log not yet redone, in KB) and redo_rate (how fast redo applies it, in KB per second). You can also add both columns to the Always On dashboard in SSMS.
Write the values down at three moments: a quiet hour, a busy hour, and during your index maintenance window. Then write your own query to collect them. One number from one moment tells you nothing. Three moments start to tell you what is normal for your server.
Reading this DMV is light, so it's safe on a busy server. It works in SQL Server with availability groups and in Azure SQL Managed Instance.
Read the full lab post: Serial vs Parallel Redo: What Slows Redo Inside and Outside SQL Server
See the runbook and the artifacts: lab.dbatopro.com
Glossary
Term | What it means |
|---|---|
Availability group (AG) | A SQL Server feature that keeps copies of databases on other servers (replicas). |
Backlog | Log that reached the secondary but is not redone yet. |
Hot-tail inserts | Inserts on an ever-increasing key, like an identity column. Every new row goes to the last page. |
Main redo thread | In parallel redo, the thread that reads the log and hands records to the workers. |
Parallel redo | Redo done by several worker threads at the same time. The default in SQL Server 2016 and later. |
Redo | The work a secondary replica does to apply the log it receives from the primary. |
redo_queue_size | Log on the secondary not redone yet, in KB. |
redo_rate | How fast the secondary applies the log, in KB per second. |
Root cause | The real origin of a problem, not the first symptom you see. |
Secondary replica | A copy of the database in an AG. It receives and applies changes from the primary. |
Serial redo | Redo done by a single thread, one record after another. |
Trace flag 3459 | A global SQL Server setting that turns off parallel redo. |
Ultra Disk | Azure's fastest managed disk type, with very low latency. |
How I write: every post starts from my own notes and experience. I use AI tools to help draft and edit, and I review every word before it goes out.
Disclaimer: The views expressed in this article are those of the author and do not necessarily reflect the official policy or position of Microsoft. The author is a Microsoft employee. The technical details are based on publicly available Microsoft documentation as of November 2026.


