Restore speed is rarely limited everywhere at once. A restore passes through seven phases, from reading the repository to booting the guest, and one usually dominates. The usual suspects are chain rehydration, processor limits on the proxy doing decompression, and the write into production storage. The repository itself is less often the cause than the post-incident report suggests.
A restore expected to take two hours takes seven. The team watching cannot tell whether the delay sits in the repository, the network, the backup server or the host receiving the data, so the record says backup storage is slow and the next budget carries a line item that will not fix it. Some phases are settings that can change before the next test. Others are structural. Treating the restore as one number hides which kind of problem is in front of the team.
Storage takes the blame because it is the only component in the path that is visibly a storage product. It owns one phase of seven, and in most slow restores not the largest.
There is also a measurement artifact. Many restore progress indicators report data written, not data read. While the software rehydrates a long chain, progress appears to stall even though a great deal of reading is happening. The operator sees a frozen percentage and concludes the repository has stopped responding.
Almost none of this needs new tooling. Restore session logs carry timestamps for session start, first data transfer and machine registration, and subtracting them gives phase boundaries precise enough to find the dominant one. The hosts supply the rest: a proxy core pinned for the whole run answers the decrypt and decompress question, interface counters show whether transport was saturated, and latency and queue depth on the destination datastore show whether the write was the constraint. Gathered during a scheduled restore test rather than an incident, these take minutes.
| Restore phase | What usually dominates it | Where the fix lives |
|---|---|---|
| Read from repository | Object size and request concurrency, not media speed | Configuration first, then hardware |
| Decrypt and decompress | Processor capacity on the proxy or backup server | Hardware, or moving the role to a larger host |
| Chain rehydration | How many increments sit between the point and its full | Configuration: chain type and full frequency |
| Transport | Gateway placement and the path between components | Configuration, sometimes network hardware |
| Write to target | Production storage contention at the destination | Hardware, or choosing a quieter destination |
| Register and boot | Guest startup, service dependencies, application recovery | Neither, mostly application design and sequencing |
A file server registers and boots in a minute. A database replaying a transaction log takes as long as the log demands, and no storage decision changes that.
Settings. Chain rehydration is the clearest configuration lever. The frequency of fulls sets an upper bound on how many increments a restore has to read, and the backup method a job uses decides how the chain is built. Shortening the chain shortens the restore and costs capacity, a trade to make deliberately rather than inherit. Transport is usually configuration too: where the reading component runs, relative to both repository and destination, decides how many times data crosses the network, and gateway placement that suited a local repository can dominate after it moves. When the repository sits on the team's own network rather than across an internet link, that path is entirely under its control.
Hardware. Decrypt and decompress are genuinely hardware. If the proxy is processor bound during restores, more cores is the remedy, and a cheap one next to replacing storage. Encryption adds work whether or not it is needed, so know where it happens in the data path, and know that the key has to be available at restore time or the phase never starts.
Neither. Registration and boot belong to the workload. The realistic response is to avoid the phase by running the machine straight from the backup while it migrates in the background, which is instant recovery as Veeam documents it. That trades a fast return to service for reduced performance during the move, with its own consequences after the guest is up.
A quarterly test is worth more when it records phase boundaries rather than one duration: the restore point chosen and its distance from the nearest full, timestamps at session start, first transfer, transfer complete and guest login, plus proxy processor load and destination latency during the run. Run it on two deliberately different workloads, one small with a shallow chain and one large with a deep one. The comparison isolates rehydration cost better than any single test and gives the team a restore throughput figure it can quote. Then note which phase was largest and what was done about it, so the next purchase rests on a history rather than a repeat of the same guess.