The data usually arrives intact. What goes missing is the scheduled job nobody listed, the login that did not come across and the query that ran in two seconds on the old server and two minutes on the new one.
This free database migration checklist moves one production database, for DBAs, platform engineers and MSPs. It covers the three common cases: a major version upgrade, a move to a managed cloud database service, and an engine change such as Oracle or SQL Server to PostgreSQL. It runs from assessment and schema conversion through a timed rehearsal, data validation and a performance comparison, to a cutover with a freeze, a rollback point and an approved go/no-go. The output is a database running on its new platform, validated against the source, with the old instance on its way out.
This checklist works at the level of a single database. Moving a whole application, with its servers, network and load balancers, to AWS, Azure or Google Cloud is a workload migration, and that starts with the Cloud Migration Checklist. When its strategy step lands on Replatform, swapping a self-managed database for a managed service, the database itself moves here and the workload runbook waits for the result.
Version upgrade
Same engine, newer release
Changes: the optimiser, defaults and deprecated features.
Typical method: in-place upgrade, or a side-by-side copy.
Main risk: query plans that change after the upgrade.
Platform move
Same engine, new home
Changes: the host, often to a managed service with no operating system access.
Typical method: backup and restore, native replication or a migration service.
Main risk: features, jobs and logins the managed service handles differently.
Engine change
A different database engine
Changes: data types, procedural code, case and date handling.
Typical method: schema conversion, then a migration service with change data capture.
Main risk: code that converts cleanly but behaves differently.
What the Database Migration Checklist Covers
Seven phases take one database from assessment to a decommissioned source. The migration type decides whether schema conversion tasks appear, the downtime approach decides whether data moves by replication or in the outage, and the change owner approves the cutover before writes stop. Open one record per migration.
Phase 1
Phase 1: Scope & Assessment
The migration type and downtime approach recorded on the first task decide which tasks appear in Phases 2, 4 and 5.
Open the migration record and set the type, approach and owners — version upgrade, platform move or engine change; offline or online; the database owner, application owner and change owner
Measure the size and the rate of change — data and log volume, the largest tables and the changes per hour at peak, which set how long copying and catching up will take
Inventory everything in and around the database — schemas, procedures, triggers, scheduled jobs, linked servers, extensions, logins and encryption settings
Find every client that connects — application configs, reports, ETL jobs and spreadsheets; the database’s own connection logs show who really uses it
Check the target supports what you use and how it is licensed — managed services drop some features, extensions and operating system access
Agree the downtime the business will accept — in minutes, from the application owner; it decides between offline and online
Phase 2
Phase 2: Schema, Code & Method
The first three tasks appear only for an engine change.
Run a conversion assessment and size the manual work — a report of what converts automatically and what has to be rewritten by hand
Convert the schema and rewrite what did not convert — procedures, functions, data types, sequences and implicit conversions
Test the application’s queries against the converted schema — sorting, null handling, case sensitivity and date arithmetic differ between engines
Build the target and apply the schema with indexes and constraints held back — secondary indexes, foreign keys and triggers slow the bulk load or break it
Recreate logins, permissions and scheduled jobs on the target — data migration tools move tables, not users or agent jobs
Choose and record the migration method — backup and restore, native replication, dump and load or a managed migration service, and why
Phase 3
Phase 3: Rehearsal & Baseline
Capture a performance baseline on the source — the slowest and most frequent queries and key transaction times, across a full business cycle
Rehearse the whole migration on production-sized data — and time every step: copy, catch-up, index builds, validation and repointing
Validate the rehearsal copy with the checks planned for cutover — row counts, checksums and sample queries, so the checks themselves are tested
Run the application tests and baseline queries against the rehearsal copy — a slow query found now is a tuning task; found after cutover it is an incident
Write the cutover runbook from the rehearsal timings — each step with an owner, a measured duration and the check that proves it worked
Set the rollback point and the trigger — the last moment you can still go back, and what happens to writes made on the target after it
Phase 4
Phase 4: Sync, Freeze & Go/No-Go
The replication tasks appear only for an online migration. The change owner records Approved or Not approved on the last task, and the checklist halts until they decide.
Start the full load and change data capture — add secondary indexes before the change phase begins, so applying changes does not scan whole tables
Watch replication lag and validation results until cutover — batch jobs and index rebuilds on the source can push lag to minutes or more
Take a full backup of the source and prove it restores — this is the copy you fall back to if everything else fails
Freeze schema changes and releases on the source — a column added mid-migration breaks the copy or silently misses the target
Tell users, the service desk and integration owners the window — what stops, for how long and who to call
Approve or reject the cutover — the change owner records the decision, with the rehearsal timings and validation results attached
Phase 5
Phase 5: Cutover
The final copy appears for an offline migration; draining replication appears for an online one.
Stop application writes and record the time — maintenance mode on, source jobs disabled, sessions drained
Take the final backup or dump and load it on the target — timed against the rehearsal; past the trigger, roll back
Let the last changes apply, then stop replication — lag at zero and the final change applied before anything points at the target
Enable constraints, triggers and jobs on the target — foreign keys validated, not just switched on
Run the cutover validation checks — row counts on every table, checksums on key tables and the sample queries the application owner chose
Repoint applications, reports and integrations to the target — connection strings, DNS aliases and data source definitions
Go live or roll back at the trigger time — after the application owner’s smoke test; rolling back means pointing clients at the untouched source
Phase 6
Phase 6: Post-Cutover Monitoring
Watch errors, connections and blocking for the first business day — a client still connecting to the old server shows up in its logs
Compare performance with the source baseline — the same queries at the same load, fixing regressions with indexes, statistics or plan guidance
Refresh statistics and confirm maintenance jobs run — index maintenance, integrity checks and statistics updates on their new schedule
Confirm backups run on the target and test a restore — a managed service’s defaults may not match your retention policy
Record the application owner’s acceptance — Accepted, or Not accepted with the open issues listed
Phase 7
Phase 7: Decommission & Close
Keep the source read-only until the rollback period ends — stopped or read-only, never deleted while a rollback is possible
Hand the old instance to server decommissioning — backup jobs, monitoring, firewall rules and service accounts all go
Cancel the source’s licences and support contracts — the saving only arrives when they stop
Close the change and update the CMDB and runbooks — with the validation evidence and acceptance attached
The method follows from two numbers measured in Phase 1: how much data there is and how long the business can be without it.
Method
Downtime
Suits
Watch for
In-place upgrade
The upgrade run
Version upgrades on the same server
Whether the old version can still be started afterwards
Backup and restore
Backup, copy and restore time
Same engine, moderate size
Restore time growing with the database
Dump and load
Export plus import and index builds
Small databases, version jumps
Index and constraint builds dominating the window
Native replication
Minutes to drain
Same engine, large or busy databases
Version and edition limits on replication
Migration service with change data capture
Minutes to drain
Engine changes and moves to managed services
Objects the service does not create
What the migration services do and do not move
AWS DMS creates tables and primary keys on the target, but not secondary indexes, foreign keys or user accounts, which is why Phase 2 builds those separately. AWS also warns that its change data capture has no latency SLA and can lag by minutes or more under heavy source load. Its data validation compares source and target row by row, but only for tables with a primary key or unique index. For an engine change, DMS Schema Conversion produces an assessment report of what converts automatically and what needs manual work, which is the input to Phase 2.
Azure Database Migration Service currently covers SQL Server moves to Azure SQL Database (offline), and to Azure SQL Managed Instance and SQL Server on Azure Virtual Machines (online or offline). It migrates schemas but not logins.
Version upgrades have their own traps
On SQL Server, query optimiser changes follow the database compatibility level, not the engine version. Microsoft’s recommended path is to upgrade, keep the old compatibility level, let Query Store capture a baseline, then raise the level and force the earlier plan for any query that regresses. On PostgreSQL 18, pg_upgrade carries most optimiser statistics across, but not extended statistics created with CREATE STATISTICS, so plan a statistics refresh after the upgrade. In link mode the old cluster cannot be used once the new one has started, so your rollback point is the backup, not the old cluster.
Why Run Database Migrations in CheckFlow?
1
The rehearsal becomes the runbook
A table inside the rehearsal task holds each step, its owner and its measured duration, and the cutover runbook is written from those rows. Dynamic due dates count back from the cutover date, so the rehearsal and backup test land in time.
2
One template for every migration
Conditional logic shows schema conversion tasks only for an engine change, and replication or final-copy tasks according to the downtime approach. The cutover approval goes to the change owner picked on the first task, and nothing stops writes until they decide.
3
Validation you can show later
Row count reports, checksum output and baseline comparisons attach to the tasks they prove. The activity trail records who validated what and when, and the application owner’s acceptance is a field on the record, not an email.
What is the difference between a homogeneous and a heterogeneous database migration?
+
A homogeneous migration keeps the same engine, for example SQL Server on-premises to Azure SQL Managed Instance, so the schema and code move largely unchanged. A heterogeneous migration changes the engine, for example Oracle to PostgreSQL, so the schema and procedural code have to be converted and retested first. Heterogeneous migrations carry most of their risk in that conversion, not in the data copy.
How long does a database migration take?
+
The project time depends on the type: a version upgrade may take weeks of testing, an engine change months of conversion work. The cutover itself depends on the method. An offline copy takes as long as the backup, transfer and restore, while an online migration with replication needs only minutes to drain. The only reliable figure comes from a full rehearsal on production-sized data, which is why Phase 3 times every step.
How do you validate data after a database migration?
+
Use several checks, because each misses something. Compare row counts for every table, compare checksums or hashes of key tables or columns, and run sample queries chosen by the application owner, such as last month’s totals. Migration services can add row-by-row validation. Run the same checks in the rehearsal, so you know they work and how long they take before the cutover window.
How do you roll back a database migration?
+
Point the applications back at the source, which stays untouched and read-only until the rollback period ends. The hard part is data written to the target after cutover: either set the rollback trigger before any production writes reach the target, or plan reverse replication from the target to the source. If the source cannot be restarted after an in-place upgrade, the rollback point is the verified backup.
Should I use a migration service or native database tools?
+
For a same-engine move, native backup and restore or replication is usually simpler and keeps everything the engine knows about. A service such as AWS DMS earns its place for engine changes and for online moves where native replication is not available between the two platforms. Either way, check what the tool leaves behind: indexes, constraints, logins and jobs often have to be built separately.
Is CheckFlow free for this template?
+
14-day free trial, no card required. The Business plan is $10 per user per month after the trial. Full details at checkflow.io/pricing.
Rehearse the Cutover Before It Counts
Free trial — no credit card required.
Do you like cookies? 🍪 We use cookies to ensure you get the best experience on our website. Learn more