AWS publishes a formula for data-transfer timelines. Feed it 100 TB on a 1 Gbps circuit at 80% utilisation, 24 hours a day, and it returns 11.57 days — which AWS itself calls “a theoretical minimum transfer time.” The formula has no term for how fast your data changes while you copy it. In a datacenter migration plan, that missing term matters more than the initial copy: it decides how long the move really takes, and when rolling back stops being a configuration change and becomes a data-recovery project.
A full migration plan also covers discovery, dependency mapping, wave planning, network and security changes. This guide focuses on the part that most often decides whether the move can be undone: the data.
The point of no return is the first write, not the DNS change
Every migration has a point of no return. It is tempting to put it at the DNS change, but a DNS change can be reversed. The point of no return is the first write that exists only on the new side. Before it, rollback means redirecting traffic. After it, rollback means moving data backwards.
How much runway you have before that point depends on one number — the convergence ratio: how much of your data changes per day, divided by how much your replication link can carry per day. Below 1.0, replication catches up, you can run both sites in parallel, and rollback stays a routing decision. At 1.0 or above, replication never catches up, and the cutover becomes a write freeze. That freeze is your real outage, whatever the maintenance window says.
AWS’s DataSync guidance recognises the problem — “For actively used data with frequent modifications, plan for multiple waves of incremental transfers” — but incremental waves only help when the ratio is below 1.0. Compare the change rate with the circuit first.
Seed time is not convergence time
Using AWS’s formula — data size × 8 ÷ (circuit × utilisation × 3,600 × available hours) — at 80% utilisation and 24 hours a day, each circuit delivers a fixed daily ceiling:
| Circuit | Delivered per day at 80% | Seed time, 20 TB | Seed time, 40 TB | Change rate that never converges |
|---|---|---|---|---|
| 100 Mbps | 0.864 TB | 23.2 days | 46.3 days | ≥ 0.86 TB/day |
| 1 Gbps | 8.64 TB | 2.3 days | 4.6 days | ≥ 8.64 TB/day |
| 10 Gbps | 86.4 TB | 5.6 hours | 11.1 hours | ≥ 86.4 TB/day |
| 25 Gbps | 216 TB | 2.2 hours | 4.4 hours | ≥ 216 TB/day |
Computed from AWS’s DataSync formula at 80% utilisation and 24 hours a day; the same method reproduces AWS’s 100 TB example at 11.57 days. AWS describes the result as a theoretical minimum, so each row is a best case.
Now the part the formula leaves out. While you ship the initial copy, the source keeps changing. Shipping that change takes time, during which more change accrues. The series sums to seed time ÷ (1 − convergence ratio):
| Dataset (1 Gbps) | Change rate | Convergence ratio | Seed time | Estimated time to converge |
|---|---|---|---|---|
| 40 TB | 1 TB/day | 0.12 | 4.6 days | 5.2 days |
| 40 TB | 3 TB/day | 0.35 | 4.6 days | 7.1 days |
| 40 TB | 6 TB/day | 0.69 | 4.6 days | 15.2 days |
| 40 TB | 7.8 TB/day | 0.90 | 4.6 days | 47.6 days |
| 40 TB | 8.64 TB/day | 1.00 | 4.6 days | never |
All five rows have the same seed time, so a plan built on the seed alone budgets 4.6 days in every case. At a 0.69 ratio the estimate is 15.2 days; at 0.90 it is 47.6 days — ten times what the formula gave you. Treat these as estimates, not bounds: they inherit AWS’s best-case throughput, which pushes real convergence up, and they assume changes never overwrite the same blocks, which pushes it down. What the model shows is how sharply the answer moves as the ratio nears 1.0.
Two practical consequences. If the ratio is close to 1.0 on the circuit you have, widen the circuit, shrink the set you migrate in one wave, or — for very large datasets on slow links — ship the initial copy on physical media and replicate only the changes over the network. And if the replication link is a faster uplink, check how it is billed: Hetzner’s unlimited-traffic policy “does not apply to servers that have the 10G uplink addon.” See metered vs unmetered bandwidth.
Rollback in practice: what the vendor guidance says
AWS’s cutover guidance draws the line in the same place. A rollback before any data has changed “can be as simple as resuming the on-premises instances and then redirecting your traffic.” But if the application “has received new transactions and data, then you might have to restore the data from the cloud environment to the on-premises environment.” AWS lists three ways to keep that possible: a fail-forward database that replicates from the new environment back to the old one, a dual-write strategy, and native backup and restore.
It also defines what a rollback plan needs: checkpoints that trigger a rollback, a strategy for handling the data, and a named person who decides whether to fix forward or roll back.
Failback is not simply failover in reverse. In Azure Site Recovery’s Azure-to-Azure disaster recovery, failing back needs a reprotect job that replicates in the opposite direction, and Microsoft documents that “checksum differential data transfer happens at approximately 23% of disk throughput,” with recovery-point processing adding around one-fifth on top. It is a second replication job, not an undo button.
The same applies to migration tools in general: read what “finalise” and “revert” actually do before you write them into a plan. A step that stops replication and removes the replicated data also removes your cheapest rollback path, and a revert that changes a status field does not bring back writes made on the new side.
A delayed replica buys a recovery point, not a rollback
Rolling back after the write cutover needs the old site to hold the new site’s writes — AWS’s fail-forward pattern, set up before cutover rather than after an incident.
A delayed replica solves a different problem, and the two belong together. MySQL’s CHANGE REPLICATION SOURCE TO SOURCE_DELAY = N keeps a replica N seconds behind its source; the first documented purpose is “To protect against user mistakes on the source. With a delay you can roll back a delayed replica to the time just before the mistake.” Point it at the new primary, and a bad migration script or a corrupting bug on the new side can be stopped before it reaches the copy.
PostgreSQL’s recovery_min_apply_delay does the same job — “It may be useful to have a time-delayed copy of the data, offering opportunities to correct data loss errors” — and documents the cost on the same page: “longer delays will result in a greater accumulation of WAL files, increasing disk space requirements for the standby’s pg_wal directory.” It also warns that hot_standby_feedback “will be delayed by use of this feature which could lead to bloat on the primary.”
Do not confuse low lag with safety. MySQL notes that a Seconds_Behind_Source value of 0 “can usually be interpreted as meaning that the replica has caught up with the source, but there are some cases where this is not strictly true.” A green dashboard is not a converged dataset.
The cutover sequence, with the rollback gate in it
Inventory and measure: dataset size, file or object counts, and baseline IOPS and disk throughput at average and peak load.
Measure the change rate over a full business cycle, so monthly batch jobs are inside the sample. This is the numerator of the ratio.
Compute the convergence ratio and multiply the seed estimate by 1 ÷ (1 − ratio). If the result exceeds the project window, widen the circuit or shrink the migrating set. Fix the arithmetic, not the schedule.
Build the destination and test it while it is not serving live traffic — functional and non-functional tests before the cutover window.
Set up both copies before the write cutover: replication from the new primary back to the old site, and a delayed replica of the new primary with SOURCE_DELAY or recovery_min_apply_delay set to your rollback window. Size log storage for the delay.
Write down the rollback gate: the checkpoints that trigger it, the data strategy, and the named person who decides fix-forward or roll back.
Rehearse with real read traffic. Send a share of read-only or stateless traffic to the new site while writes stay on the old one, and rehearse the failback path as well as the migration. DNS has its own failure modes — record-level failover is bound by TTLs, and some resolvers hold records longer than instructed; see anycast DNS.
Cut over writes last, and record the timestamp. That timestamp, not the DNS change, is when your rollback window starts counting down.
Keep the old site until the rollback window has expired, then decommission. Set that window from the old contract’s exit terms, not from the cutover date.
What breaks in production
The source lock sets the outage. AWS notes you may need to lock the source “prior to starting the cutover process” and that “locking may require a larger downtime window.” If the ratio is above 1.0 this is your only option, and its length is the outage.
Replication lag reported as zero. Validate convergence with row counts or checksums, not with the lag field.
Small files. AWS: “Expect higher data throughput for transfers with larger files (MB or GB) compared to smaller files (KB).” A small-file set can fall well short of the ceiling in the table above.
Rollback rehearsed in one direction only. If the migration is rehearsed and the failback is not, the first run of the reverse path happens during an incident.
The read-only lock. In Azure-to-Azure reprotection the source machine is locked “to prevent deletion,” and “the lock remains until the failback to the source region completes.” Tooling that expects to modify or delete that machine has to be planned around it.
Decommissioning to save money. Stopping replication or releasing the old servers on cutover night removes the cheapest rollback path while the rollback window is still open.
The parallel run is priced by the contract you are leaving
The cost of keeping a rollback window open is set by the exit terms of the contract you are leaving — and those terms differ product by product, even inside one vendor.
Hetzner’s documentation is a clear example. For dedicated servers, “You can only cancel immediately,” and Hetzner bills “by the hour and never exceed[s] the monthly price cap,” excluding additional hardware and licences. Rackspot reservations are billed daily up to the date of cancellation. For colocation, “The cancellation period depends on the individual contract.”
Read that the right way round. On hourly-billed dedicated servers with immediate cancellation, a longer parallel run costs only the hours the old servers stay on, capped at the monthly price — so cutting the rollback window short to “stop paying twice” saves little and risks a lot. On a colocation exit, the term that prices your rollback window is one no price list publishes.
The entry side is set at order time too. OVHcloud’s US Advance range states that “the setup fees for your dedicated server are included for any commitment period of 12 months or longer” — so the cheapest way in is a one-year commitment, which becomes the exit term of your next migration. The two vendors’ fee structures are compared in Hetzner vs OVH.
Three questions before you schedule the cutover
Is your convergence ratio below 1.0? If not, there is no parallel run to plan — only a freeze whose length you should give the business now. If it is, multiply the seed estimate by 1 ÷ (1 − ratio) and plan against that figure.
How long is your rollback window, in hours, and what is the delayed replica set to? If you cannot answer with a number, you have a rollback intention, not a rollback plan.
What does one more day on the old site cost under the old contract? Hourly billing with immediate cancellation makes a long rollback window cheap; a colocation notice period or a multi-month commitment may already fix its price.
Migrating with INXY.hosting
INXY.hosting dedicated servers have no setup fee and no minimum term, in the EU and the US. That matters twice in a migration: the destination can be built and tested without committing to a term, and it does not become a locked-in exit term for your next move. Because we source across multiple providers on one invoice, parallel-run windows and exit terms can be planned before the migration rather than discovered during it.
The useful starting point is a business cycle of change-rate data and the exit terms of your current contracts — not a Gantt chart. Our DevOps and managed infrastructure team runs the arithmetic above against your own numbers. If the move is off a hyperscaler, start with the economics in cloud repatriation.
FAQ
How long should a datacenter migration plan allow for data transfer?
Start from AWS’s DataSync formula — data size in bits divided by circuit speed, utilisation and available hours — which AWS calls a theoretical minimum. Then divide the result by 1 minus your convergence ratio. A 40 TB set on 1 Gbps seeds in 4.6 days but takes about 15 days to converge if it changes 6 TB a day.
What is the point of no return in a migration?
The first write that exists only in the new environment. Before it, rollback is a routing change. After it, rollback means moving data backwards — in AWS’s words, restoring “the data from the cloud environment to the on-premises environment” — which is a recovery project rather than a configuration change.
Does a migration tool’s revert button undo a cutover?
Do not assume it does. Check what the tool’s finalise and revert steps actually do: if finalising stops replication and removes the replicated data, a later revert may only change a status, not bring back writes made on the new side. Keep reverse replication running until the rollback window closes.
How do I keep a cheap rollback option after cutover?
Replicate from the new primary back to the old site before the write cutover — AWS’s fail-forward approach — and add a time-delayed replica of the new primary using SOURCE_DELAY in MySQL or recovery_min_apply_delay in PostgreSQL, so a bad change can be stopped before it reaches the copy. Budget extra log storage for the delay.
Is replication lag of zero safe to cut over on?
Not on its own. MySQL documents that Seconds_Behind_Source can read 0 in cases where the replica has not fully caught up. Confirm convergence with row counts or checksums against the source before the write cutover.
