Zero-Downtime Database Migrations: A 4-Phase Tutorial (Expand and Contract Pattern)
Renaming or modifying database columns in production breaks applications because code deployments and database migrations cannot happen simultaneously. The solution is the Expand and Contract pattern (Parallel Run), breaking a destructive change into four non-breaking release phases:
Phase 1: Expand (Add without deleting)
Add the new column/table as nullable or with a non-blocking default value.
Never alter or delete existing columns during this step.
Example: Adding full_name while keeping first_name and last_name active.
Phase 2: Dual-Writing (Application Update 1)
Update your application layer to write incoming data to both the old and new fields.
Read logic continues to pull from the old field to ensure backwards compatibility with legacy service instances during rollout.
Phase 3: Backfill and Switch Reads (Application Update 2)
Run an asynchronous, throttled background script to backfill historical records from the old column to the new column in small batches (avoiding table-wide row locks).
Once the backfill finishes and data integrity checks pass, deploy an application patch that directs all read queries to the new field.
Phase 4: Contract (Database Cleanup)
Verify through metrics that zero reads/writes touch the old column.
Deploy code that removes the legacy write path.
Finally, drop the old column/table using a lightweight migration.
Key Takeaways
Never perform breaking schema changes in a single deployment step.
Decouple database structure changes from application code releases using dual-writing.
Always batch historical backfills to prevent lock escalation on production databases.
CTA (Invite members to participate)
How does your team currently handle schema migrations on high-traffic databases? Do you prefer dual-writing in application code, or do you rely on database triggers and CDC tools like Debezium? Drop your war stories and preferred tooling in the comments.
Renaming or modifying database columns in production breaks applications because code deployments and database migrations cannot happen simultaneously. The solution is the Expand and Contract pattern (Parallel Run), breaking a destructive change into four non-breaking release phases:
Phase 1: Expand (Add without deleting)
Add the new column/table as nullable or with a non-blocking default value.
Never alter or delete existing columns during this step.
Example: Adding full_name while keeping first_name and last_name active.
Phase 2: Dual-Writing (Application Update 1)
Update your application layer to write incoming data to both the old and new fields.
Read logic continues to pull from the old field to ensure backwards compatibility with legacy service instances during rollout.
Phase 3: Backfill and Switch Reads (Application Update 2)
Run an asynchronous, throttled background script to backfill historical records from the old column to the new column in small batches (avoiding table-wide row locks).
Once the backfill finishes and data integrity checks pass, deploy an application patch that directs all read queries to the new field.
Phase 4: Contract (Database Cleanup)
Verify through metrics that zero reads/writes touch the old column.
Deploy code that removes the legacy write path.
Finally, drop the old column/table using a lightweight migration.
Key Takeaways
Never perform breaking schema changes in a single deployment step.
Decouple database structure changes from application code releases using dual-writing.
Always batch historical backfills to prevent lock escalation on production databases.
CTA (Invite members to participate)
How does your team currently handle schema migrations on high-traffic databases? Do you prefer dual-writing in application code, or do you rely on database triggers and CDC tools like Debezium? Drop your war stories and preferred tooling in the comments.
Zero-Downtime Database Migrations: A 4-Phase Tutorial (Expand and Contract Pattern)
Renaming or modifying database columns in production breaks applications because code deployments and database migrations cannot happen simultaneously. The solution is the Expand and Contract pattern (Parallel Run), breaking a destructive change into four non-breaking release phases:
Phase 1: Expand (Add without deleting)
Add the new column/table as nullable or with a non-blocking default value.
Never alter or delete existing columns during this step.
Example: Adding full_name while keeping first_name and last_name active.
Phase 2: Dual-Writing (Application Update 1)
Update your application layer to write incoming data to both the old and new fields.
Read logic continues to pull from the old field to ensure backwards compatibility with legacy service instances during rollout.
Phase 3: Backfill and Switch Reads (Application Update 2)
Run an asynchronous, throttled background script to backfill historical records from the old column to the new column in small batches (avoiding table-wide row locks).
Once the backfill finishes and data integrity checks pass, deploy an application patch that directs all read queries to the new field.
Phase 4: Contract (Database Cleanup)
Verify through metrics that zero reads/writes touch the old column.
Deploy code that removes the legacy write path.
Finally, drop the old column/table using a lightweight migration.
Key Takeaways
Never perform breaking schema changes in a single deployment step.
Decouple database structure changes from application code releases using dual-writing.
Always batch historical backfills to prevent lock escalation on production databases.
CTA (Invite members to participate)
How does your team currently handle schema migrations on high-traffic databases? Do you prefer dual-writing in application code, or do you rely on database triggers and CDC tools like Debezium? Drop your war stories and preferred tooling in the comments.
English
Arabic
French
Spanish
Portuguese
Turkish
Dutch
Italiano
Russian
Romaian
Portuguese (Brazil)
Greek