ARTESCA Blog | Backup, recovery and cyber resilience

How to diagnose slow restore speed, phase by phase

Written by Joshua Silvia | Sep 20, 2026, 3:34:43 AM

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.

Seven phases between the request and a working machine

  1. Read from the repository. The backup software requests the blocks for the restore point. On object storage this is a sequence of object reads, and object size and request concurrency influence it more than raw media speed.
  2. Decrypt. Processor work on whichever component the software designates, usually a proxy or the backup server.
  3. Decompress. More processor work on the same component. A restore running on a two core virtual machine is limited here whatever the repository can deliver, and nothing in the symptom points at the processor.
  4. Chain rehydration. A restore point that is an increment cannot be served alone. The software reads the full it depends on and every increment in between, then assembles the blocks. A point twenty increments deep reads far more data than a synthetic full, though both produce the same machine. This is the phase most often mistaken for slow storage, because the storage is busy serving more data than anyone expected.
  5. Transport. Moving assembled data to the destination host or datastore.
  6. Write to target. The data lands on production storage that may already be serving users.
  7. Register and boot. Creating the machine object, attaching disks, starting the guest and waiting for the operating system and applications. On a database server this phase can outlast all the others combined.

Why the repository rarely limits restore speed

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.

Timing each phase with logs you already have

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 phaseWhat usually dominates itWhere the fix lives
Read from repositoryObject size and request concurrency, not media speedConfiguration first, then hardware
Decrypt and decompressProcessor capacity on the proxy or backup serverHardware, or moving the role to a larger host
Chain rehydrationHow many increments sit between the point and its fullConfiguration: chain type and full frequency
TransportGateway placement and the path between componentsConfiguration, sometimes network hardware
Write to targetProduction storage contention at the destinationHardware, or choosing a quieter destination
Register and bootGuest startup, service dependencies, application recoveryNeither, 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, hardware or neither

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.

Making the next test more useful

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.