About this article: This article is reviewed against the cited sources. This is source research, not lab validation. Check the stated versions and your own requirements before making changes.
An index rebuild writes a new copy of the index and discards the old one. Anything that backs up "what changed" sees that new copy as changed data: differential backups, transaction log backups and block-level image backups all grow after a rebuild, by an amount that follows the size of the indexes rebuilt, not the amount of business data that changed.
Rebuild fewer indexes, or only the ones that need it, and the growth falls. Where a rebuild is needed, schedule it so it lands in a full backup rather than in a week of differentials.
What the symptom means
The documentation does not say "a rebuild makes backups larger" in one sentence. The effect follows from three things Microsoft does document.
The rebuild writes a new index. Microsoft's index maintenance page says "rebuilding an index drops and re-creates the index", that the physical media "must have enough space to store two copies of the index", and, for rowstore indexes with more than 128 extents, that "the data rows are copied and sorted, then moved to new allocation units created to store the rebuilt index." Every page of a rebuilt index is therefore written again.
A differential backup records changed extents. The differential backup page says it "captures the state of any extents (collections of eight physically contiguous pages) that have changed" since the base full backup, using "a bitmap page that contains a bit for every extent." Extents holding a rebuilt index are changed extents. A differential keeps growing until the next full backup resets its base: "generally, the older a base is, the larger a new differential backup will be."
A log backup holds the logged work. Under the full recovery model, the transaction log page says "all bulk operations are fully logged", so a rebuild is fully logged and the next log backup carries it. Under the bulk-logged model, ALTER INDEX ... REBUILD is "minimally logged", but Microsoft's recovery model page warns that "log backups might be large because the minimally logged operations are captured in the log backup." Under the simple model there are no log backups, and rebuilds are minimally logged "except when a backup is running".
Block-level backups work below SQL Server. VMware's documentation says changed block tracking lets machines "keep track of disk sectors that have changed". A rebuild rewrites sectors in the data file, and it may also grow the file because two copies must coexist, so those sectors count as changed.
All three of these are consequences, not measurements. Prove them on your own server before acting.
Likely causes
| Cause | What you see | How to confirm |
|---|---|---|
| Rebuild-all maintenance plan runs between the full and the differentials | Each differential is far larger than the daily business change; it grows to nearly the rebuilt index size on day one | msdb.dbo.backupset rows of type = 'I' have large backup_size from the first backup after the maintenance window |
| Full recovery model, rebuild runs overnight | A log backup after the window is much larger than the others | Same table, type = 'L', compare the backup after the window to others |
| Bulk-logged model used around the window | Log backups are large and has_bulk_logged_data = 1 |
Query below; also check the recovery model column |
| Image backup reads data file blocks | Incremental size tracks the rebuilt index volume, not the application's change | The image job's changed-data figure matches index sizes in sys.dm_db_index_physical_stats |
| Low fill factor on rebuilt indexes | Rebuilt indexes occupy more pages than needed | avg_page_space_used_in_percent is low; Microsoft says low page density means "more pages are required to store the same amount of data" |
Prove the cause before changing anything
These queries only read.
- See backup sizes around the maintenance window.
msdb.dbo.backupsetholds a row for every backup, includingtype(D full, I differential, L log),backup_start_date,backup_size,compressed_backup_size,recovery_modelandhas_bulk_logged_data:
SELECT database_name, type, backup_start_date, backup_size, compressed_backup_size,
recovery_model, has_bulk_logged_data
FROM msdb.dbo.backupset
ORDER BY database_name, backup_start_date DESC;
backup_size is the size in bytes. Look at the first differential or log backup after each maintenance window, and compare it with the others. A repeated spike at the same point each day points at the rebuild.
-
Find out what the maintenance window rebuilds. Open the maintenance plan or SQL Server Agent job that runs index maintenance and note whether it rebuilds every index or only those over a fragmentation threshold.
-
Size the indexes. Microsoft's index maintenance page uses this query for fragmentation and page density:
SELECT OBJECT_SCHEMA_NAME(ips.object_id) AS schema_name,
OBJECT_NAME(ips.object_id) AS object_name,
i.name AS index_name,
ips.avg_fragmentation_in_percent,
ips.avg_page_space_used_in_percent,
ips.page_count
FROM sys.dm_db_index_physical_stats(DB_ID(), DEFAULT, DEFAULT, DEFAULT, 'SAMPLED') AS ips
INNER JOIN sys.indexes AS i
ON ips.object_id = i.object_id AND ips.index_id = i.index_id
ORDER BY page_count DESC;
page_count is in 8 KB pages; multiply to estimate GB. The sum for the indexes your plan rebuilds is a floor for the growth from each run, not a ceiling. The SAMPLED mode returns results quickly; Microsoft notes DETAILED is more accurate but scans all index pages and "can take a long time".
A good result for your suspicion is a spike that matches the rebuilt index size. A bad result, where backups are large on days with no rebuild, means look elsewhere, for example at the causes in "Differential backup getting bigger every day: why the base never moves" and "SQL Transaction Log Keeps Growing: Find the Real Cause".
Example (illustrative): database db01 is 200 GB, of which indexes are 120 GB. Real business change is about 2 GB a day. A weekly full backup is followed by six differentials, Monday to Saturday, and a rebuild-all job runs every night before the differential. The differential of day n then holds at least the rebuilt indexes (120 GB) plus the changes since the full (2 x n GB): about 122, 124, 126, 128, 130 and 132 GB if each night's rebuild reuses the same extents, and 762 GB for the week. Each rebuild writes to new allocation units, so later differentials can be larger, up to the used size of the database. Without the rebuild, the differentials would be 2, 4, 6, 8, 10 and 12 GB, a total of 42 GB. The rebuild alone accounts for at least 6 x 120 = 720 GB of the difference. These are uncompressed figures; real figures depend on how much of the real change falls inside the rebuilt extents.
Fix
Rebuild only what needs it
Microsoft's guidance is that "index maintenance decisions should be made after considering multiple factors in the specific context of each workload" and "shouldn't be based on fixed fragmentation or page density thresholds alone." Its recommended strategy is to measure the effect, try updating statistics instead ("resource cost of updating statistics is minor compared to index rebuild"), and "reorganize or rebuild specific indexes used by queries with degraded performance" rather than every index. The linked guidance article covers that decision; here the point is that every index left alone is backup volume avoided.
Reorganise (ALTER INDEX ... REORGANIZE) is described as "less resource intensive than rebuilding an index" and as the preferred method unless there is a reason to rebuild. Microsoft does not state how many fewer bytes a reorganise leaves for backups, so treat its saving as likely but measure it.
Rebuild just before the full backup
A differential holds what changed since its base. If the rebuild runs just before the weekly full backup, its pages go into the base rather than into the differentials that follow. If it runs after the full, every differential until the next full carries it. This follows from the differential description above. Changing the schedule means the full backup runs after the rebuild, so check it still fits the backup window.
Risk (both fixes above, rebuilding only what needs it and rebuilding just before the full backup): reducing or moving rebuilds can change query performance and backup-window length. Back out by restoring the previous maintenance plan or schedule (save a copy first).
Do not switch to bulk-logged as a fix
Bulk-logged logging is minimal for rebuilds, but Microsoft warns log backups "might be large" in that model, so it is not a reliable way to shrink them.
Risk: Under the bulk-logged model, "point-in-time recovery isn't supported", and "if the log is damaged or if bulk-logged operations occurred since the most recent log backup, changes since that last backup must be redone." Switching models for the maintenance window narrows what you can restore to. Changing the recovery model is a decision for the database owner. Switching back does not recover what the window lost.
Check fill factor
Microsoft does not recommend a fill factor other than 100 or 0 "except in certain cases for indexes experiencing a high number of page splits". A low fill factor makes each rebuilt index larger, which makes each rebuild larger.
Confirm the fix
After the next maintenance window, rerun the backupset query. The first differential and log backup after the window should be near the size of a normal day's change, and the weekly differential total should fall toward the no-rebuild figure. For image backups, compare the job's changed-data figure for the following night.
What to watch afterwards
- Watch
backup_sizeof differentials week over week; a maintenance plan change that returns to rebuild-all shows up quickly. - Record when each full backup runs relative to the rebuild.
- Microsoft notes that a copy-only backup does not change the differential base, so an extra copy-only full does not reset a growing differential. The differential-growth fault itself is covered elsewhere.
Read next
Related articles you may want next.
- HostingIndex and statistics maintenance on hosted SQL Server: what current guidance recommendsWhether a nightly index rebuild helps a business application, what Microsoft's current guidance says about fragmentation thresholds and statistics, and how to decide by measuring rather than by habit.Read article
- TroubleshootingSQL Transaction Log Keeps Growing: Find the Real CauseSeparate log reuse, physical file growth and disk exhaustion, then identify the evidence needed for a DBA-approved SQL Server remedy and recovery check.Read article
- Backup & RecoveryBacking up the backup folder: SQL .bak files that double the server backupSQL .bak files on a local disk are backed up again by the server backup. Work out the cost, why compressed dumps hurt, and the options for fixing it.Read article
Risks and limits
- These commands have not been run or lab-tested. The queries come from Microsoft Learn pages for SQL Server 2017 to 2025; Azure SQL services have different recovery behaviour and are not covered.
- Microsoft's pages do not state how many bytes a rebuild adds to a differential or a log backup. The sizes in this topic are floors derived from the documented mechanics. A differential can be larger, because a rebuild of a rowstore index writes to new allocation units and a differential holds every extent changed since the full backup.
- A reorganise or a statistics update is documented as cheaper, not as producing a particular backup size.
- Compression and encryption of backups change
backup_sizeandcompressed_backup_size; "Compressed and encrypted files do not deduplicate: what that does to backup storage" covers why. - The transaction log page describes minimally logged index operations. Minimal logging of index operations is described on the transaction log page cited here.
- Figures in the example are made up to show the arithmetic.
Sources
- Maintain indexes optimally (reorganize and rebuild indexes) — Microsoft Learn, 27 October 2026
- Differential backups (SQL Server) — Microsoft Learn, 21 January 2026
- The transaction log (SQL Server) — Microsoft Learn, 26 August 2025
- Recovery models (SQL Server) — Microsoft Learn, 20 February 2026
- Transaction log backups (SQL Server) — Microsoft Learn, 21 January 2026
- backupset (Transact-SQL) — Microsoft Learn, 21 September 2026
- Virtual Disk API: low level backup procedures (changed block tracking) — Broadcom, copyright 2005-2024, no page date
This article was originally published on .