Why is a big-bang cutover risky?
The first approach that comes to mind when renewing a legacy system is to rewrite it from scratch and switch everyone over on a set date. Known as a “big bang” cutover, this looks clean on paper: one project, one cutover day, and the old system shuts down that day. In practice, three problems grow at once.
- A long freeze period. While the new system is being prepared, new features for the old system are either postponed or built twice. Business units wait for months; temporary workarounds—another Excel file or an extra approval email—multiply during the wait.
- One-time data migration. Years of accumulated data are full of undocumented fields, inconsistent records, and exceptions. Moving everything overnight means discovering problems for the first time in production.
- A moving target. The business keeps changing during the project: new products, regulations, and partners. By the time the new system is complete, some of the original requirements are no longer valid.
Hidden business rules add to these problems. In legacy systems, many rules exist only in code and the memories of a few experienced employees. In a full rewrite, some are discovered only after cutover, when something goes wrong.
Strangler fig: renewing around the legacy system
The alternative is to replace the system in pieces. Known in software as “strangler fig” and popularized by Martin Fowler, the model is named after a tree: a strangler fig starts growing on another tree, gradually sends roots into the ground, and eventually replaces its host. The host remains standing throughout the process.
In software, a routing layer is placed in front of the legacy system, capabilities are rewritten one by one in the new system, and traffic for each capability is redirected when it is ready. The legacy system continues running until its last module has been transferred. Each stage goes live independently; users begin seeing value in the first stage rather than at the end of the program.
Phased transition does not mean less work. Operating two systems together and managing their data flow for a time takes additional effort. In return, risk is divided into smaller parts; the outcome and rollback limit of each stage can be assessed separately.
Steps in a phased transition
The steps below form a cycle repeated for each module. To make the explanation concrete, consider a hypothetical distributor whose ordering, pricing, stock, invoicing, and reporting functions run in one legacy system developed over twenty years.
1. Map modules, dependencies, and data
First establish what the system actually does: its functions, which teams use them, which modules write to which tables, and which overnight jobs and integrations run. Build this map through both code review and observing users at work; either alone is incomplete. Document which system is the source of truth for each data type at this stage.
2. Choose the first slice
A good first slice delivers visible business value, has few dependencies, and produces measurable results. In the example, invoicing may look attractive, but depends on accounting, stock, and tax integrations; it is a heavy first step. A quotation screen used daily by sales is often a better candidate: it is used frequently, its slowness is well known, and it touches only a few tables. Read-only reporting is also a low-risk start, though its value may be limited.
3. Put a routing layer in front
Users and other systems access the legacy system through an API gateway or routing layer rather than directly. Initially the layer forwards all requests to the legacy system; nothing changes. At each subsequent stage, only relevant requests are routed to the new system. On the interface side, a shell application combining old and new screens under one menu can serve the same role.
4. Keep data synchronized between both systems
During transition, the same data exists in both systems. There are two common approaches:
- Dual writes: The application sends a change to both old and new systems. One of two independent writes may fail; operation order, duplicate checks, compensation, and regular reconciliation must be designed separately. Writing the same data in two places does not ensure consistency by itself.
- Change data capture (CDC): Changes are read from the legacy database transaction log and passed to the new system as events. Because this synchronizes without changing legacy code, it is often preferred when modifying that code would be risky.
Whichever method is chosen, each record must have a single source of truth, and a reconciliation report comparing both sides must run regularly. The source of truth may change when a module moves to the new system. If data must flow back to the legacy system, reverse transfer is designed separately; do not assume the direction changes automatically. CDC support also depends on the database, permissions, and data transformations.
5. Run in parallel and compare
Before go-live, the new module runs in shadow mode for a period: read requests or operations with isolated side effects are compared in both systems; users receive the legacy response. Payments, emails, stock deductions, or third-party records must not be generated twice. Differences are one of the most reliable ways to uncover hidden business rules. For example, a discount applied only to a particular dealer group at month-end may emerge from this comparison rather than the documentation.
6. Shift traffic gradually
Once differences fall to an acceptable level, traffic moves gradually to the new module: first internal users, then a region or dealer group, then everyone. A feature flag may control traffic cutover; moving data created in the new system back is separate work. Rehearse in advance the latest point at which rollback remains possible, who can initiate it, and data reconciliation.
7. Shut down the old module and measure
Once all traffic has moved, actually shut down the old module: remove code paths, stop overnight jobs, and archive necessary data. Every legacy module left running is a second system still needing maintenance. Then assess the stage against predefined criteria: transaction time, error rate, response time, requests to return to old screens, and legacy operating cost. Meaningful comparison requires recording baseline values before cutover.
Migrating data from a legacy system: rehearsal, reconciliation, and rollback
Completing migration does not mean the data is usable. For example, equal total order counts can still conceal a customer's debt assigned to the wrong customer. The cutover decision should rely on results accepted jointly by the technical team and the owner who uses the data in their work.
- Mapping and cleanup. Document each old field's new counterpart, persistent record identifier, date and currency, status codes, and customer relationships. The business owner decides whether blank, duplicate, or invalid records will be corrected, archived, or excluded from migration.
- Trial migration. Perform migration with representative data in an access-restricted test environment; mask personal data where needed. Measure duration, load on the source system, rejected records, and the effects of rerunning it.
- Reconciliation. Alongside record counts, compare amounts by customer, period, currency, and status, as well as order line items and related documents. Audit critical fields at record level. Explain expected transformation differences; assign an owner and a resolution to unexplained differences.
- Final changes and cutover. Capture records changed after the initial load. If necessary, establish a write-freeze window; move users once pending work, the last synchronization point, and acceptance checks are complete. Base the window's duration on rehearsal results.
- Rollback rehearsal. Which errors stop cutover, who decides, and what is the last safe rollback point? Test separately how orders and payments created in the new system will be entered into the old one. Restoring a backup cannot automatically reverse an operation already performed in an external system.
Example scenario: phased migration of a quotation screen
Let the new screen prepare draft quotes while pricing and customer records remain in the legacy system. In the first rehearsal, compare products, units, discounts, and rounding for the same quote in both systems; shadow operation must not send a second quote to the customer.
If users need to return to the old screen after pilot cutover, first list drafts created on the new side using their persistent identifiers. If there is a status code the legacy system does not recognize, reverse transfer stops; the business owner decides on the mapping. Switching the interface back does not reverse finalized orders or documents already sent externally.
The person accepting the cutover reviews the list of unresolved differences and the rollback rehearsal together. Do not decide to retire the old module until reconciliation is complete. This is an example flow; the downtime window and rollback limits are defined separately for the real project.
AWS's data validation documentation explains comparing source and target records and the additional resources validation requires. Its post-migration rollback example also demonstrates the importance of a separate rollback strategy for changes created on the new side (checked: 13 October 2026). Choose the tool according to your own systems' capabilities; the software modernization scope includes these rehearsal and acceptance steps.
Timeline: when does the first stage go live?
Phased modernization is planned with a roadmap. The example timeline below varies with data preparation, access, and the first module's dependencies:
- Discovery (1–2 weeks): System, data, and process maps; risk map; first-slice recommendation. We cover the content and outputs of a discovery sprint in a separate article.
- Definition and prototype (2–3 weeks): Screens and integration design for the first slice; the prototype is tested with real users in week 3.
- Build (2-week sprints): Working software is shown each week; the first stage, with scope agreed together, is planned to go live in 6–12 weeks.
- Subsequent stages: Other modules are sequenced on the roadmap; each goes through the same cycle and launches independently.
Large programs such as core system modernization do not fit into a single 6–12-week project and should not be forced to. Explaining from the start that this timeframe covers the first stage rather than the entire program sets realistic expectations.
Phased transition does not guarantee zero downtime in every system. Data transformations, external integrations, or rollback limits may require a maintenance window; the acceptable duration is determined during discovery. Source of the approach: Martin Fowler — Strangler Fig (checked: 11 October 2026).
Risks and how to reduce them
Phased transition does not eliminate risk; it makes it visible and divides it into smaller parts. Key risks and mitigations in these programs include:
| Risk | What it looks like | How to reduce it |
|---|---|---|
| Hidden business rules | The new module produces different results for some records | Shadow-mode comparisons; record discovered rules in automated tests |
| Data divergence | The same customer or order appears differently in two systems | A single source of truth, CDC synchronization, regular reconciliation reports |
| Unfinished transition | Old and new systems are operated together indefinitely | Include the old module's retirement date in each stage's definition |
| Additional latency | The routing layer increases response time | Keep the layer thin and monitor response times from day one |
| User resistance | Teams want to return to old screens | Test prototypes with real users before development; transition gradually |
There is also an organizational risk: the people who know the legacy system best usually carry the daily workload too. Planning their time in advance during discovery and parallel operation is as important as technical precautions.
What should be prepared before handing existing software to a new team?
Taking over a running system does not mean rewriting it immediately. First establish that the new team can set up the current version in a separate test environment and reproduce a core workflow. If the problems are limited, maintenance and small improvements may be more appropriate than full modernization.
The source archive has been delivered; is the handover really complete?
Handover acceptance relies on evidence that the new team can operate the system and that responsibilities are clear. The table below is an example acceptance framework; it does not mean every project requires transferring every account or granting everyone administrator rights.
| Area | Evidence to require | Decision if evidence is missing |
|---|---|---|
| Code and deployment | Source matching the running version, modification/use rights, dependency records, and a repeatable build/deployment in the test environment | Locate the missing setup step or asset before committing to production changes. |
| Accounts and access | Account owner, access owner, and billing/renewal owner for the domain, cloud, database, email, and any app stores | Clarify access tied to individuals and the right to grant permissions; do not request a list of passwords. |
| Backup and restore | Restore results in a separate environment, controlled access to required keys/settings, and verification of a core workflow | Do not treat the existence of a backup file as proof of recoverability; clarify data-loss and downtime limits. |
| External dependencies | Package/version inventory, vendor support, license limits, and owners of external APIs and service accounts | Do not finalize scope until maintainability and modification rights have been verified. |
| Background jobs and cost | Scheduled jobs, queues, retry limits, stop permissions, and ownership of usage-based costs | Define an activation sequence that prevents old and new environments from executing the same job twice. |
| Support responsibilities | Monitoring access, known issue list, incident decision-maker, and the start of responsibilities between old and new teams | Do not automatically treat source delivery as the start of maintenance or a guarantee of uninterrupted support. |
Transferring accounts is not the same as cleaning up access. For example, during a GitHub repository transfer, webhook, secret, and deploy key records may remain associated with the repository; permission and feature effects of moving between accounts need separate checks. Do not assume legacy service connections have been closed just because ownership changed.
In what order should responsibility be transferred?
- Define boundaries: Document which modules, data, and support hours will transfer, and which gaps remain outside scope.
- Review and rehearse first: Start with the minimum access required. Verify installation, a core operation, and restoration in a test environment using appropriately masked or synthetic data.
- Create a decision record: Each gap should have an owner, business impact, and a reason for acceptance or deferral. If the running system can continue through maintenance, a rewrite is not mandatory.
- Transition under control: Verify new permissions and service connections; sequence removal of old access and rotation of required keys according to dependencies. Urgent security situations such as incident response require a separate plan.
Example decision: The new team can run the ordering screen, but the overnight stock job exists only in the former developer's personal account, and restoring the backup has never been tested. A narrow screen-maintenance scope may be considered; the full takeover is not complete until responsibility for stock processing and data recovery is demonstrated. This is a fictional scenario, not a customer result.
Microsoft's Dynamics 365 support transition guide also treats support scope, roles, and operational readiness separately. This general handover framework is an example of Codariva's approach; it is not a commitment to support or take over every technology. To evaluate your existing system, explore the software modernization scope. For the first conversation, share the system's purpose, technologies, and who currently holds access rather than passwords or production data.
Checklist before you start
Clarifying the following items before starting the first stage will also make the rest of the program easier.
Phased modernization checklist
- Modules, dependencies, and data have been mapped; each module has a business owner.
- The source-of-truth system for each data type is documented.
- The first slice is chosen: visible value, few dependencies, measurable results.
- The routing layer is designed; traffic destinations are managed in one place.
- The synchronization method (dual writes or CDC) and reconciliation report are defined.
- The outputs to compare during parallel operation and the acceptance criteria are defined.
- Traffic and data rollback steps, decision authority, and the last safe rollback point are defined and rehearsed.
- The old module's retirement date is included in the stage plan.
- Baseline values for success metrics were recorded before cutover.
See how this approach translates into screens in the Insurance Infrastructure Modernization product concept: at the fictitious X Sigorta, the first stage is a single-screen comprehensive motor quote and an event bridge keeping the legacy core system and new platform synchronized. Scope, stage sequence, and delivery conditions are available on our software modernization service page.
If you would like to identify the first slice for your own system together, request a conversation about a discovery sprint.