ERP Implementation Phases Explained: What Happens in Each Phase
ERP implementation phases from readiness check to Run: exit criteria, 4 to 9 month mid-market timelines, SIT and UAT gates, and proof artifacts.
Key takeaways
- Run readiness after you pick a platform direction and before kickoff. After kickoff, the phase gates in this guide take over.
- Order-to-cash, procure-to-pay and record-to-report are mapped as they run today, and each has a named process owner.
- Ask in your next leadership meeting who owns order-to-cash after go-live, not only during the project.
What "ERP implementation phases" means
ERP implementation phases are the named, sequential stages a rollout passes through from the moment a platform is selected to the point it runs the business in steady state. Each phase has a defined purpose, a set of activities, and, the part most teams underuse, a set of deliverables and exit criteria that must be satisfied before the next phase begins. The phases are methodology-agnostic: whether you follow a waterfall, agile, or hybrid approach, the same lifecycle stages appear, just sliced differently.
Microsoft's Success by Design framework, built from thousands of real Dynamics 365 projects, makes this explicit. It describes implementation as a continuous practice of architecting, building, testing, and deploying a solution, and it maps that practice into named phases with associated reviews at the phase boundaries. The point of phasing is to force the team to surface risks early, while design and build decisions are still cheap to reverse.
That discipline matters more than the software brand. Practitioners describe the same pattern when a rollout goes wrong: ripping out an ERP is rarely a tooling problem; it is a data-migration and change-management problem across every department that touches the system. Phases exist to make those problems visible before go-live, not after.
This guide treats phases as a deliverables-and-governance structure, not only a calendar. If you want week-by-week durations and schedule math, use the ERP implementation timeline guide. If you want the people who own each phase, use the implementation team roles guide. If you want cutover weekend mechanics, use the go-live checklist and cutover plan. Here the focus is narrower and more useful for steering: for each phase, what is produced, how long it usually takes as a share of the project, and what evidence proves it is done.
The six-phase ERP implementation model at a glance
The widely used industry model splits an ERP rollout into six phases: Discovery, Design, Build, Test, Deploy, and Run. NetSuite's published implementation guidance frames ERP rollout as exactly this kind of structured, phased project, and Microsoft's lifecycle guidance aligns to the same arc: Discovery and Design map to its Discover and Initiate phases, Build and Test to Implement, Deploy to Prepare, and Run to Operate. SAP Activate uses Discover, Prepare, Explore, Realize, Deploy, and Run, different labels for the same work. Different vendors use different phase names, but the underlying lifecycle is consistent.
Some mid-market playbooks split the same arc into seven or eight named steps (separating planning from discovery, data migration from build, or hypercare from go-live). That is useful for resourcing, data migration and training often run as parallel workstreams, but the governance spine stays six phases with hard gates. The table below is the reference you can hand to a steering committee. It pairs each phase with its core goal, a realistic share of a mid-market project, and the single deliverable that best proves the phase is complete. The rest of this guide expands each row into activities, artifacts, and exit criteria.
| Phase | Core goal | Typical share (mid-market) | Primary deliverable (proof it is done) |
|---|---|---|---|
| 1. Discovery & Planning | Define why you are implementing, what is in scope, and how you will measure success | ~10 to 15% | Approved business case, scope document, success metrics, RAID log |
| 2. Design | Translate requirements into a concrete future-state solution design | ~15% | Signed-off Solution Blueprint (design document + fit-gap register) |
| 3. Build | Configure the platform, build customizations, and prepare data migration | ~25% (+ data migration parallel) | Configured non-production environments, working integrations, draft migration scripts |
| 4. Test | Prove the built solution works start-to-finish on real scenarios with real data | ~15% | SIT complete + UAT sign-off from business owners across critical processes |
| 5. Deploy (Go-Live) | Cut over from legacy to the new system with trained users and a support net | ~10% | Completed cutover runbook, passed go/no-go, live hypercare plan |
| 6. Run | Stabilize, hand over to business-as-usual support, and start optimizing | ~5 to 15% (hypercare window) | Hypercare exit report and transitioned support model with optimization backlog |
How long each phase takes: mid-market vs enterprise ranges
Phases answer what work happens; duration answers how long it takes under stated assumptions. A realistic mid-market cloud ERP project runs about 4 to 9 months from kickoff through hypercare. Small, near-standard cloud deployments can finish in 2 to 4 months. Large multi-entity, multi-country programs with heavy customization commonly run 12 to 24 months or longer. Those ranges assume a defined scope, a dedicated buyer-side team, and configuration-first design, not endless rewrites of legacy processes.
Within a six-month mid-market plan, a practical week-range picture looks like this: Discovery and requirements about 2 to 4 weeks; project planning and governance 1 to 2 weeks (often overlapping Discovery); solution design 3 to 5 weeks; build and configuration 4 to 8 weeks; data migration 3 to 6 weeks in parallel; SIT and UAT 3 to 5 weeks; training and go-live 2 to 4 weeks; post-go-live hypercare and early optimization 4 to 8 weeks. Several workstreams overlap on purpose, data cleansing should start in Discovery, not after Build "finishes." Compressing below these ranges almost always sacrifices process design or testing, both of which surface as production pain within three months of go-live.
Enterprise ranges stretch the same phases, not invent new ones. Design and Build expand with legal entities, localizations, and integration surface area. Test expands because SIT must cover more external systems and performance envelopes. Deploy may become a multi-wave cutover rather than a single weekend. Run may include 8 to 12 weeks of formal hypercare before issue volume returns to operational baseline. The assumptions that invalidate any published range are the usual ones: dirty master data left unowned, customization by default, part-time process owners, and a go-live date that is a calendar commitment rather than a readiness decision.
Use phase share as a health check, not a contract. If Design is still open after 25% of the calendar is gone and Build has already started on unsigned gaps, you are not "ahead of schedule", you are building against assumptions. If Test is planned as a two-week rubber stamp after a nine-month Build, the project has already decided to discover defects in production. Duration without exit criteria is just a Gantt chart.
| Business size | Typical users / shape | Realistic total timeline | What stretches the plan |
|---|---|---|---|
| Small business | 5 to 25 users; near-standard cloud config | 2 to 4 months | Dirty data, last-minute custom reports, weak training |
| Mid-market | 25 to 250 users; moderate config + integrations | 4 to 9 months | Multi-site inventory, e-commerce/CRM integrations, change capacity |
| Enterprise | 250+ users; multi-entity / multi-country | 12 to 24+ months | Localizations, phased waves, heavy customization, dual-system period |
Phase 1 (Discovery and planning): define the why and the scope
Discovery is where the project either gets a solid foundation or stores up problems for later. The team gathers and validates business requirements, documents current-state pain points, and finalizes the high-level solution approach. Equally important, Discovery is where the non-functional groundwork is laid: the environment strategy (which sandboxes and production tenants you need and when), the organizational change strategy, and the data governance stance that will govern every later phase. Start master-data profiling here, waiting until Build is how dirty customers, invalid emails, and orphaned foreign keys become go-live blockers.
The deliverables that prove Discovery is done are concrete and reviewable. A business case states the expected benefits and ties them to measurable success metrics (order-to-cash cycle time, month-end close days, inventory accuracy). A scope document defines which legal entities, processes, and integrations are in and, just as importantly, out. A current-state process inventory and a prioritized requirements list give Design something to work from. A RAID log (risks, assumptions, issues, decisions) becomes the living risk register. Success by Design specifically recommends starting the Solution Blueprint Review during Discovery rather than deferring it, because that is when architectural risks are cheapest to surface.
Exit criteria for Discovery are governance-based, not technical. They typically include a signed-off business case and scope, named success metrics with baselines, a drafted environment strategy, a named project team with budget and time allocation (not "on top of the day job" only), an opened RAID log, and a change-management outline. If the team cannot answer "what does success look like, numerically?" Discovery is not finished, and every later phase will inherit that ambiguity.
ERP readiness assessment: the gate before Discovery
An ERP readiness assessment checks whether a company has the process clarity, clean data, free hours and sponsor authority to carry an implementation. It sits in front of Phase 1: if the answers are weak, Discovery turns into a rescue exercise and every later phase inherits the gaps. Treat it as a half-day workshop with named owners, not a survey.
Flectic uses six dimensions and scores each from 0 to 2: 0 means missing or unknown, 1 means partial with no owner, 2 means an owner and evidence are in place. That is a working scale we use, not a published standard. A total of 10 to 12 out of 12 is ready to scope. A total of 8 or 9 is conditional: start Discovery only when each gap has an owner and a date. Below 8, run a prep cycle first and re-score before you sign an implementation scope.
- Run readiness after you pick a platform direction and before kickoff. After kickoff, the phase gates in this guide take over.
| Dimension | A score of 2 looks like | Evidence to attach |
|---|---|---|
| Executive sponsorship | Named sponsor with budget authority who joins steering and clears blockers within the week | Sponsor mandate and meeting cadence |
| Process maturity | Order-to-cash, procure-to-pay and record-to-report are mapped and each has an owner | Process maps and named process owners |
| Data quality | Master data audited and de-duplicated, with migration rules agreed and a governance owner | Data audit and owner name |
| Internal bandwidth | A project lead with protected hours and a super-user per function, with day-to-day work covered | RACI and weekly hours committed |
| Integration map | Every system that must connect to the ERP is listed with an owner and an interface type | Integration inventory |
| Change capacity and budget | Adoption and training have their own budget line, and the timeline assumes real internal workload | Budget line and draft change plan |
Signs you are not ready yet, and what to fix first
A low score is a signal to prepare, not a verdict. The usual root causes are poor planning, underestimated implementation risk and unwillingness to change processes. Fix the flag before you shortlist vendors or sign a scope.
| Red flag | Risk if ignored | Fix first |
|---|---|---|
| Vague goals and no definition of done | Scope churn, and no way to judge success six months after go-live | Write 3 to 5 measurable outcomes with baselines |
| Scope keeps changing | Budget and timeline grow; the partner cannot finish a design | Freeze a first-phase scope list and an explicit out-of-scope list |
| Low user engagement | Shadow spreadsheets return and adoption stalls | Name super-users and bring them into workshops now |
| Lift-and-shift mindset | Customizations balloon and broken processes get rebuilt | Challenge every "must customize" request against the business case |
| No legacy data plan | Bad data moves faster and users lose trust in week one | Run a master-data audit and name a governance owner |
| Sponsor in name only | Blockers sit for weeks while committees decide | Give the sponsor a written mandate and a weekly slot |
| ERP treated as a one-time IT project | Drift after go-live as workarounds return | Fund change management and name post-go-live owners |
| No integration inventory | Surprise interfaces late; cutover fails on bank, CRM or warehouse links | List every system that must connect on the first day |
ERP readiness checklist: items to confirm before Discovery
The scorecard rolls up into a short checklist. Answer each item with "yes, with an owner and evidence". Any item that fails becomes a prep work package with a name and a date instead of a silent risk. Items that duplicate the phase artifacts above, such as the business case and RAID log, are left out here.
- Order-to-cash, procure-to-pay and record-to-report are mapped as they run today, and each has a named process owner.
- The standard operating procedures people follow are written down, and their last review date is recorded.
- Customer, vendor and item records are audited, classified as master or transaction data, and de-duplicated.
- Naming and format conventions are agreed, and one person owns data governance.
- A project lead has protected weekly hours; a part-time lead is acceptable for a company of 20 to 100 people when the hours are written down.
- Each function has a named super-user, and their day-to-day work has a coverage plan.
- Every first-day integration (bank, tax, e-commerce, warehouse, payroll, CRM) is listed with an owner.
- The sponsor has budget authority and decision rights, documented in writing.
- Change management, training and internal backfill appear in the budget next to licenses and consulting fees.
- Three to five success measures are agreed with baselines before kickoff.
How can executives tell if their organization is ready to move to cloud ERP?
Cloud ERP readiness is often mistaken for an IT exercise about networks, security and app compatibility. Overruns and late go-lives more often trace to leadership alignment, data quality, process clarity and change readiness. Executives can check four operating signals.
First, core processes (finance, inventory, purchasing, production) have named owners. Second, someone approves changes to roles, workflows and extensions, so the system does not drift. Third, operational data has consistent definitions and a steward. Fourth, leadership expects the ERP to need ownership after go-live, because cloud platforms update continuously.
Warning signs are the reverse: critical processes live in spreadsheets and tribal knowledge, decision rights are unclear, departments define the same field differently, and leadership expects the software to fix operating problems by itself. When those patterns dominate, pause vendor demos and score the six dimensions first.
- Ask in your next leadership meeting who owns order-to-cash after go-live, not only during the project.
- If you cannot name a steward for customer and item data, hold back on analytics promises.
- If every change waits for a monthly committee with no mandate, you have delay rather than governance.
| Signal area | Ready | Not ready yet |
|---|---|---|
| Process ownership | Named owners and documented workflows | Spreadsheets and informal workarounds |
| Governance | Defined approval for system changes | Anyone can change a process ad hoc |
| Data | Consistent definitions and named stewards | Duplicates and conflicting names |
| Leadership stance | ERP is a long-term operating platform | ERP is a one-time IT project |
| After go-live | Hypercare and an improvement owner | Team disbands on go-live day |
A 90-day prep plan when the score is below 8
If the total is below 8, spend up to 90 days closing the lowest-scoring dimensions before you sign an implementation scope. Each step ends with a gate you can inspect. The week-by-week project schedule that follows is in the ERP project plan guide, and the 90-day ERP readiness playbook covers the scorecard in more depth.
Days 1 to 30: diagnose
Score the six dimensions with owners in the room. Document how order-to-cash, procure-to-pay and record-to-report run today, audit master data, draft the integration inventory, and name the sponsor and project lead. Gate: scorecard done, current-state maps and data audit exist, sponsor and lead named.
Days 31 to 60: decide and clean
Work on the lowest scores first, usually data, process ownership or bandwidth. Set measurable objectives, such as days to close the books. Standardize formats, remove duplicates and map fields for the first-phase data. Approve a budget that includes adoption and training. Gate: objectives signed, budget approved, data clean enough to migrate for the first phase, two weak dimensions improved.
Days 61 to 90: mobilize
Lock scope with an explicit out-of-scope list, confirm super-users and their protected time, and agree who owns processes and data after go-live. Re-score. Gate: scope frozen, super-users committed, a total of 8 or more, and any residual gap logged with an owner.
ERP readiness for an acquisition: Day-1 systems and cutover
After an acquisition the clock is set by the deal, not by the project. The acquired company needs to operate on Day 1, or inside a controlled Day-30 window, with intact finance, inventory visibility and order fulfillment. A 12-month redesign is not on offer, so scope the minimum that has to work.
Treat the target as a small readiness assessment with a hard external deadline. Score the six dimensions for both companies, then list what must work on Monday morning: legal entities, a chart of accounts or a mapping table, customer, vendor and item rules, open payables and receivables, inventory balances, tax setup, bank connections, and who can post journals.
The common failures are two charts of accounts that never reconcile, customer IDs and units of measure that differ between systems, no data owner on the target side, and a sponsor who disappears after the announcement. The integration map matters more here than in organic growth projects, because intercompany and reporting deadlines do not wait for process redesign. Harmonize what Day-1 reporting and control require, and redesign the rest after hypercare. The cutover mechanics are in the ERP cutover plan guide.
| Workstream | Day-1 must-have | After Day 1 |
|---|---|---|
| Legal and finance structure | Entity live, chart of accounts mapped, period close owned | Full policy harmonization |
| Master data | Customers, vendors and items de-duplicated for the active set | Historical clean-up and archive strategy |
| Transactional cutover | Open payables and receivables, inventory, open sales and purchase order rules | Deeper order-to-cash and procure-to-pay redesign |
| Integrations | Bank, tax and warehouse if shipping on Day 1 | CRM, marketing and secondary tools |
| People | Sponsor, target-side finance lead and a super-user named | Role redesign and the full training curriculum |
Phase 2 (Design): turn requirements into a future-state solution
Design converts validated requirements into a buildable solution. The team maps current-state processes to future-state processes, runs a fit-gap analysis to separate what the platform does out of the box from what must be configured or built, and makes the hard integration, data-model, and security decisions. This is also where customization versus configuration choices get made explicitly, with each gap challenged before any code is written. Configure to standard wherever the process is not a true competitive differentiator, every bespoke build is a permanent tax on testing, upgrades, and support.
The central deliverable is the Solution Blueprint, the future-state design document that defines process flows, the data model, the security and role model, the integration architecture, and the configuration approach. Alongside it sit a fit-gap register (each gap logged with a disposition), a reporting and analytics design, a draft data migration approach with field-level mapping rules, and a training-needs outline so role-based training is not invented in week before go-live. In Success by Design, the Initiate phase is where the in-scope workstreams are defined and the project plan is updated, and the Solution Blueprint Review starts in Discover. SAP Activate's Explore phase plays the same role with fit-to-standard workshops.
Exit criteria for Design center on a formal sign-off. The Solution Blueprint must be reviewed and approved by both the implementation partner and the business sponsors, with the fit-gap register accepted. Microsoft frames its Solution Blueprint Review as an exercise in reflection, discovery, and alignment, matching the design against known good patterns to catch risks before they become expensive. Build starts after the blueprint is signed. Skipping or rubber-stamping this gate is the most common reason teams build the wrong thing fast.
Phase 3 (Build): configure, customize, and prepare the data
Build is where the solution takes shape in a non-production environment. The team configures the platform against the signed-off design, develops any approved customizations and extensions, stands up integrations, and builds the first versions of the data migration routines. Application lifecycle management (ALM) is set up here so that configuration and code can move predictably between environments rather than by manual export-import. Work in short, reviewable increments so functional leads validate as you go rather than only at the end of a long black box.
Treat data migration as a first-class parallel workstream, not a late task. Profile and cleanse legacy data, map fields, run trial loads into a sandbox, and validate with the people who own the data. Multiple trial migrations are normal; a single "migration weekend hope" is not. Practitioners who have lived through production-scale loads stress the same rule: testing on a database copy with a tiny fraction of production volume is hoping, not testing, volume, queue depth, and validation dashboards matter before cutover. For modern AI-assisted features, Build also includes prototyping those capabilities against defined scenarios before they are wired into core workflows.
Success by Design introduces Implementation Reviews during the build phase specifically to deepen the design decisions that the Solution Blueprint surfaced, the data model, security, and integration design, plus ALM and the testing strategy. These reviews exist to fully resolve identified risks before the build is too far along to change course cheaply.
Exit criteria for Build are technical and demonstrable. The configured solution must exist in a sandbox that users can log into; integrations must be demonstrably moving data; migration scripts must have run against sample (and ideally production-scale sample) data at least once; unit tests on customizations must pass; and there must be a working ALM pipeline. The phase is complete when an independent reviewer can exercise the start-to-finish process in the sandbox and the design-to-build traceability is intact.
Phase 4 (Test): SIT, UAT, and proof on real scenarios
Testing is where the built solution is validated against real business scenarios using migrated data, not synthetic samples. A mature test phase layers four types of testing: unit testing of individual configurations and customizations, system integration testing (SIT) across connected systems, performance testing against realistic transaction volumes, and user acceptance testing (UAT) where business owners confirm the system meets their needs. Each layer has its own entry and exit criteria, and each must run under the correct security roles rather than blanket administrator access. SIT proves modules and integrations work together under failure cases; UAT proves the business can run order-to-cash, procure-to-pay, and record-to-report with real people and real data.
The deliverables are a test plan and test cases tied to requirements through a traceability matrix, a defect log with each issue tracked to resolution, performance test results, SIT evidence that includes external-system failure scenarios, and, the artifact that matters most, documented UAT sign-off from business owners across the critical start-to-finish processes. Microsoft's guidance is explicit that testing must use migrated data under the right security roles and obtain business sign-off at each cycle, with defined exit criteria rather than a vague "looks good." Conference-room pilots or limited parallel runs are high-use when the risk profile warrants them.
Exit criteria for Test are uncompromising for a reason. UAT must be complete with documented business sign-off; SIT must include peak-volume and external-system failure scenarios; performance must be tested against realistic volumes; critical defects must be closed or formally accepted with owners; and regression coverage must exist for the paths that will run on day one. If UAT sign-off is missing or testing was done with administrator rights on dummy data, the project is not ready to deploy, regardless of the calendar. Deep UAT script patterns and defect thresholds live in the ERP UAT testing guide.
Phase 5 (Deploy): cut over with training and a support net
Deploy is the controlled transition from the tested system in a sandbox to the live production environment, with real users performing real transactions. It is a window, not a single day, that begins with a legacy system freeze, runs through a timed cutover, and continues into weeks of hypercare. The Deploy phase is where every prior shortcoming surfaces, which is why it is gated so heavily. Role-based training and super-user enablement should already be underway before the cutover weekend, not scheduled as a last-minute slide deck.
The deliverables are operational and rehearsed. A cutover runbook lists every task with an owner, a duration, and a dependency. Mock cutovers rehearse that runbook at least once, ideally twice, so the real cutover is the third run, skip dress rehearsal and you discover blockers at 2 a.m. on Saturday. Training has been delivered and super-users are in place. The support model, service hours, escalation paths, ticketing, on-call rotation, is defined. Rollback triggers are written and approved even if you never use them. And a go/no-go decision is made against documented criteria at a formal readiness meeting, not against the original press-release date.
Exit criteria for Deploy are the go-live readiness review and the go/no-go decision. Microsoft's Success by Design uses a Go-live Readiness Review in its Prepare phase to identify remaining gaps before launch, confirming scope sign-off, UAT completion, performance and integration testing, the cutover plan, and the support and hypercare model. A project earns the right to go live when a named decision-maker says "go" against that checklist. The full cutover, mock-rehearsal, and weekend sequence live in the ERP go-live checklist and cutover plan guides.
Phase 6 (Run): hypercare, stabilize, hand over, and optimize
Run is the post-go-live phase where the solution is live and the focus shifts from launch to stabilization and continuous improvement. In Success by Design this is the Operate phase: the customer solution is live, and the goal is stabilization followed by planned enhancements. For mid-market teams this typically means a defined hypercare period of intensive support that tapers into business-as-usual operations, often 4 to 8 weeks, sometimes 4 to 12 weeks for complex estates. Hypercare is a first-class phase segment, not a soft landing after the party.
A practical hypercare structure looks like this: week 1 daily issue triage, floor-walkers or dedicated war-room support, rapid fix deployment, and real-time monitoring of key transactions (issue volume usually peaks here); weeks 2 to 4 continued daily or near-daily triage with fixes moving to scheduled releases; weeks 4 to 8 (or longer) taper as severity-1/2 rates fall and super-users resolve routine issues without escalation. Stability is not "day one orders processed." Stability is a clean month-end close, a successful inventory count cycle where applicable, and ticket volume returning toward operational baseline.
The deliverables here are a hypercare exit report showing defect volume falling toward steady state, a transitioned support model (tickets now flow to the BAU team rather than the project team), and an optimization backlog of deferred scope and improvements. Stabilization metrics, ticket volume, resolution time, transaction throughput, data-quality exceptions, tell you whether the system is settling or still bleeding. Under-staffed hypercare that shares people with the next project fails at the most fragile moment.
Exit criteria for Run are the formal handover to steady-state support and the closure of the project. Hypercare exits when defect rates hit agreed thresholds and super-users can resolve routine issues without escalation. A post-implementation review captures what worked and what did not, feeding the optimization backlog and the next wave of value. Treating Run as an afterthought is how systems that launched successfully quietly degrade, the phase is where adoption and ROI are realized. Hypercare exit criteria are covered in depth in the ERP hypercare guide.
Phase artifacts checklist: what each gate should produce
Steering committees do not need another status color; they need a short list of artifacts they can inspect. The table below is a practical checklist you can paste into a project plan. Names vary by partner methodology, but if an artifact is missing at the gate, the phase is not done, even if the calendar says it is.
Use the RAID log as a continuous thread across all phases, not a Discovery-only document. Update data mapping and migration evidence every trial load. Keep training plans living documents so role changes in Design do not strand Deploy. And never treat UAT sign-off or go/no-go as verbal "thumbs up", they are dated, named decisions with residual risks accepted by an owner.
| Phase | Must-have artifacts | Gate / exit evidence |
|---|---|---|
| 1. Discovery & Planning | Business case; scope (in/out); success metrics with baselines; process inventory; requirements register; environment strategy draft; RAID log; change outline; team RACI | Sponsor sign-off on case + scope; named metrics; team funded |
| 2. Design | Solution Blueprint; fit-gap register; integration architecture; security/role model; reporting design; data mapping draft; training-needs outline | Blueprint signed by partner + business; gaps dispositioned |
| 3. Build | Configured sandboxes; customization backlog with status; integration builds; migration scripts + trial-load reports; ALM pipeline; unit test evidence | Independent walkthrough of E2E process; migrations run at least once |
| 4. Test | Test plan + scripts; RTM to requirements; defect log; SIT results; performance results; UAT scripts and outcomes | Business UAT sign-off; critical defects closed or accepted |
| 5. Deploy | Cutover runbook; mock-cutover results; training completion; support/escalation model; rollback plan; go/no-go checklist | Formal go decision; hypercare staffed and scheduled |
| 6. Run | Hypercare triage logs; severity dashboard; BAU support transition; post-implementation review; optimization backlog | Hypercare exit criteria met; project closed to operations |
Big bang, phased rollout, or pilot: which deployment pattern fits
Phase names describe what work you do; cutover strategy describes how much of the business flips at once. The wrong pattern for your risk profile can make a well-run six-phase plan still feel chaotic. Three patterns dominate mid-market and enterprise work.
Big bang switches the entire organization (or all in-scope modules and sites) on one date. Advantages: shorter overall dual-system period, a cleaner architecture from the first day, no long bridge integrations. Disadvantages: highest concentration of risk, largest training and change load in one window, little room to course-correct after the weekend. Best fit: smaller or single-site organizations with strong project discipline and tolerance for a hard cutover weekend.
Phased rollout deploys by module, department, or site over time. Advantages: lower risk per wave, learning between waves, more digestible change management. Disadvantages: temporary integrations between old and new systems, longer overall calendar, dual processes for finance or inventory during the bridge. Best fit: mid-market multi-site and complex process footprints where a single-weekend failure is unacceptable.
Pilot (often a location or legal entity first) validates design and support model before scale-up, then rolls remaining sites in waves. Advantages: real production proof before full risk. Disadvantages: pilot bias if the pilot site is unrepresentative, heterogeneous estate during the rollout window. Hybrid patterns (full module set at a pilot site, then waves) are common on 18 to 36 month enterprise programs.
Whatever pattern you choose, the phase gates do not disappear. A pilot still needs a signed blueprint, UAT, a rehearsed cutover, and hypercare. A phased module wave still needs SIT for the bridge integrations that temporary dual-running creates. Choosing "phased" sequences the risk across waves; every wave still has to show its proof.
| Pattern | How it works | Best for | Main trade-off |
|---|---|---|---|
| Big bang | All in-scope modules/sites switch on one date | Smaller / single-site; clean break preferred | Highest risk concentration on one weekend |
| Phased by module or function | Finance first, then supply chain, etc. | Mid-market needing lower per-wave risk | Bridge integrations and dual processes |
| Pilot then roll-out by site | One location proves design; waves follow | Multi-site groups; multi-country programs | Heterogeneous estate during rollout |
The deliverables and reviews that prove a phase is done
Phases without enforced exit criteria are just labels on a Gantt chart. The discipline that makes phasing work is the phase-gate review: a short, structured checkpoint where an independent reviewer confirms the phase's deliverables exist and meet quality before authorizing the next phase. Success by Design operationalizes this with three named reviews tied to the lifecycle, the Solution Blueprint Review, Implementation Reviews, and the Go-live Readiness Review, each an exercise in reflection, discovery, and alignment against known good patterns.
A useful way to think about exit criteria is that each one is either an artifact (a signed document, a configured environment, a test result) or a decision (a go/no-go, a scope change approved, a risk accepted with an owner). "Phase complete" should never be a feeling; it should be a demonstrable state backed by evidence a steering committee can inspect. This is the single most useful governance habit an SME can adopt, because it catches scope drift and quality gaps at the cheapest possible moment.
The same logic applies regardless of platform. Whether you are deploying Dynamics 365, Odoo, NetSuite, SAP, or Oracle Cloud ERP, the deliverables differ in detail but not in kind: every rollout needs a signed design before build, business-signed UAT before deploy, and a readiness decision before go-live. If your partner cannot show you the phase-gate artifacts for your project, that is itself a finding.
How vendor methodologies map to the six phases
Every major ERP vendor publishes its own named methodology, and the names differ, but the underlying lifecycle maps cleanly onto the six-phase model. Knowing the mapping helps you read partner proposals and vendor documentation without getting lost in terminology. Microsoft Success by Design, SAP Activate, Oracle's cloud implementation guidance, and NetSuite's phased rollout language all cover discovery through operate/run.
SAP Activate's six phases, Discover, Prepare, Explore, Realize, Deploy, and Run, map closely: Discover/Prepare to Discovery & Planning, Explore to Design (fit-to-standard workshops), Realize to Build and much of Test, Deploy to go-live preparation, Run to hypercare and continuous improvement. Oracle Cloud programs commonly describe planning, requirements, configuration, testing, training/change, and go-live/support, again the same spine with different labels. NetSuite's published implementation guidance describes the same structured, phased arc.
The practical takeaway for an SME is that you should not let a vendor's proprietary phase names obscure whether the real work, design sign-off, SIT/UAT, cutover rehearsal, hypercare, is being done. Insist on the deliverables, whatever the vendor calls the phase.
| Generic phase | Microsoft Success by Design | SAP Activate | Characteristic review / gate |
|---|---|---|---|
| 1. Discovery & Planning | Discover | Discover + Prepare | Solution Blueprint Review begins; project baseline signed |
| 2. Design | Initiate | Explore | Solution Blueprint / fit-to-standard sign-off |
| 3. Build | Implement | Realize | Implementation Reviews (data, security, integration, ALM) |
| 4. Test | Implement → Prepare | Realize (validate) | SIT complete + UAT sign-off |
| 5. Deploy (Go-Live) | Prepare | Deploy | Go-live Readiness Review and go/no-go |
| 6. Run | Operate | Run | Hypercare exit and handover to support |
Common phase failures and how to avoid them
Most phase failures are governance failures dressed up as schedule pressure. The first classic mistake is compressing or skipping Discovery and Design to hit a go-live date, which moves risk downstream where it is far more expensive, the Solution Blueprint exists precisely to surface architectural risks early, when they are cheap to reverse. The second is allowing Build to proceed without a signed-off design, so the team configures against assumptions rather than decisions and rework multiplies. A third is digitizing broken processes at speed instead of challenging them in Design, packaged software already priced in standard workflows; endless customization to preserve habit is how multi-year overruns start.
Data and testing failures are equally predictable. Leaving data migration to the last six weeks, testing migrations on tiny non-production samples, running UAT with administrator rights instead of real security roles, or declaring success without business sign-off all produce the same outcome: the sandbox looks ready and production breaks trust. Once users lose faith in migrated data, adoption becomes extremely hard to recover, trust is lost in a week and rebuilt over months. Training alone does not fix that; validation must live inside the migration and test phases, not only in post-cutover optimization.
Change management remains a top failure mode. Projects that hit every deadline on paper can still burn out the best people through sustained heroics, or leave after go-live because the operating model was never designed for how work runs. Under-investing in change and training (practitioners often recommend treating it as a real budget line, not a residual) shows up as shadow spreadsheets within weeks. Deploy failures almost always also include an unrehearsed cutover, a go/no-go made by deadline instead of by criteria, and a missing or under-resourced hypercare plan.
The fix in every case is the same: enforce the phase exit criteria, start data quality early, rehearse the cutover, staff hypercare, and treat Run as a real phase with its own deliverables rather than the moment everyone goes home. These failure patterns and their root causes are unpacked further in the ERP failure causes and change management guides.
How Flectic can help
Flectic runs ERP implementations on Odoo or Dynamics 365 for companies of 20 to 100 people in the US and Canada, led by a named senior consultant through five stages you approve. Flectic sends a written proposal with a fixed price for each phase before work starts. Each phase has a defined scope and price before it starts. The scorecard above is a good first agenda for the free 30-minute call: bring your scores and we will tell you whether to start Discovery or prepare first. Read the ERP implementation service, then Book a free discovery call.
Sources
Success by Design maps the Dynamics 365 implementation lifecycle into five methodology-agnostic phases, Discover, Initiate, Implement, Prepare, and Operate. The Solution Blueprint Review begins in Discover, Implementation Reviews (data model, security, integration, ALM, testing strategy) happen in Implement, and the Go-live Readiness Review happens in Prepare. Success by Design is described as agent-assisted prescriptive guidance for architecting, building, testing, and deploying solutions, built from thousands of FastTrack projects; FastTrack is Microsoft's customer success program.
learn.microsoft.comChecked Read the full official Microsoft Learn article (markdown version, ms.date 2026 to 06 to 23, updated 2026 to 07 to 15). Phase names, the three review types, and their placement are stated verbatim in the 'Success by Design phases' section.Microsoft's Dynamics 365 guidance hub is the implementation-guide corpus that contains Success by Design, the implementation guide, and the business-process guidance used to structure phased rollouts.
learn.microsoft.comChecked Confirmed via the Microsoft Learn search API (returned as a live, indexed documentation page, last updated 2026 to 07 to 07).FastTrack for Dynamics 365 is Microsoft's customer success program run by the Dynamics 365 product engineering team that helps customers implement Dynamics 365 apps and realize business value faster; the Success by Design framework is fundamental to its approach.
dynamics.microsoft.comChecked Referenced and linked from the official Success by Design article on Microsoft Learn; the program's purpose is stated there.NetSuite frames ERP implementation as a structured, phased project that requires a cross-functional team and clear scope, aligning with the widely used six-phase model (Discovery/Planning, Design, Development, Testing, Deployment, and Post-Go-Live Support).
netsuite.comChecked Fetched the live article (HTTP 200, dateModified 2025 to 11 to 12); it is Oracle NetSuite's published ERP implementation best-practice guide.A typical mid-market ERP implementation takes 4 to 9 months and follows phased discovery through post-go-live optimisation. Phase-by-phase mid-market benchmarks include Discovery 2 to 4 weeks (~10%), planning 1 to 2 weeks (~5%), design 3 to 5 weeks (~15%), build 4 to 8 weeks (~25%), data migration 3 to 6 weeks parallel (~15%), SIT/UAT 3 to 5 weeks (~15%), training and go-live 2 to 4 weeks (~10%), post-go-live 4 to 8 weeks. Small business 2 to 4 months; enterprise 12 to 24+ months. Big bang vs phased vs parallel cutover trade-offs are documented.
erpsoftwareblog.comChecked Fetched full July 2026 article content; timeline table and size ranges stated in the phase-by-phase and business-size sections.Mid-market ERP phases and durations commonly cited: Discovery & Planning 4 to 8 weeks; Design & Configuration 8 to 16 weeks; data migration parallel 8 to 20 weeks; testing 4 to 8 weeks; go-live & hypercare 2 to 6 weeks. Small cloud ERP may go live in 3 to 6 months; mid-market often 6 to 18 months; large multi-entity 18+ months. Best practices emphasize configure-to-standard, early data cleanse, rigorous UAT, and continuous improvement after go-live.
erpresearch.comChecked Fetched live page last reviewed August 1, 2026; phase/duration table and best-practice list confirmed in page body.Mid-market implementations commonly run 6 to 18 months with seven named phases including UAT (4 to 8 weeks) and hypercare/stabilisation (4 to 12 weeks post-go-live). Hypercare structures include daily triage in week 1 and tapering support; cutover-weekend dress rehearsal is essential; data migration often 15 to 25% of project cost; change management investment of ~10 to 15% of implementation budget is recommended; big bang vs phased-by-module vs pilot-by-location trade-offs are operationally defined.
erp-software.orgChecked Fetched full 2026 practitioner playbook page; phase durations, hypercare structure, and pitfall list stated in page sections.The six phases of SAP Activate are Discover, Prepare, Explore, Realize, Deploy and Run, used to structure S/4HANA and related cloud ERP programs with fit-to-standard workshops in Explore and realization/deploy/run following.
leanix.netChecked Public methodology summary page listing the six Activate phases and their purpose.Oracle outlines a multi-step cloud ERP implementation path covering planning, implementing solutions, verifying tasks, preparing for production, and ongoing operation, aligning with a phased discovery-to-run lifecycle.
oracle.comChecked Official Oracle ERP implementation overview page structure (plan → implement → verify → prepare → operate).Practitioner observation (Aug 2026): ripping out an ERP is never primarily a tooling problem; it is a data migration and change management problem across every department, and underestimating that timeline is how a six-month replatform becomes multi-year with the old system still running in parallel.
x.comChecked Fetched via X semantic/keyword search tools; post dated 2026 to 08 to 03.Practitioner observation (Jul 2026): most ERP implementations fail because of decisions made long before go-live, missing executive sponsor, broken processes digitized at speed, change management treated as a newsletter, and data migration left to the last six weeks.
x.comChecked Fetched via X keyword search; post dated 2026 to 07 to 19.Practitioner lesson (Jan 2026): migration tested only on a database copy with ~1% of production data ran far longer in production and caused cascading timeouts, production-scale data testing is required, not optional hope.
x.comChecked Fetched via X semantic search; high-engagement post (293 likes) dated 2026 to 01 to 21.Implementation lesson (Jul 2026): data migration is the trust killer at go-live; once users lose faith in migrated records, adoption is extremely hard to recover, validation must be built into migration scope before cutover, not pushed only to post-go-live optimization.
x.comChecked Fetched via X semantic search; post dated 2026 to 07 to 29 (EHR/ERP-adjacent systems implementation context).
Frequently asked questions
What are the six phases of an ERP implementation?
The widely used model is Discovery, Design, Build, Test, Deploy, and Run. Discovery defines the business case, scope, and success metrics; Design produces the signed-off Solution Blueprint; Build configures the platform and prepares data migration; Test validates the system start-to-finish with SIT and business UAT sign-off; Deploy executes the cutover with a go/no-go decision and hypercare plan; and Run stabilizes the system and hands it over to steady-state support.
How long do ERP implementation phases take for mid-market companies?
A typical mid-market cloud ERP project runs about 4 to 9 months from kickoff through early hypercare. Inside that window, Discovery is often 2 to 4 weeks, Design about 3 to 5 weeks, Build 4 to 8 weeks with data migration in parallel, Test (SIT/UAT) 3 to 5 weeks, training and go-live 2 to 4 weeks, and hypercare 4 to 8 weeks. Small near-standard rollouts can finish in 2 to 4 months; multi-entity enterprise programs commonly need 12 to 24+ months. Duration depends on scope, data quality, customization load, and team capacity, not the logo on the software.
What is an ERP readiness assessment and when should we do it?
It is a short workshop that scores whether your company has the process clarity, clean data, free hours, integration map and sponsor authority to carry an implementation. Do it after you choose a platform direction and before Discovery starts, so gaps get owners before they become project risks. Flectic scores six dimensions from 0 to 2 and recommends a prep cycle below 8 out of 12.
What is a Solution Blueprint and which phase produces it?
A Solution Blueprint is the future-state design document that defines process flows, the data model, the security and role model, the integration architecture, and the configuration approach, alongside a fit-gap register. In Microsoft's Success by Design the Solution Blueprint Review begins in the Discover phase and carries on through Initiate, which maps to the generic Discovery and Design phases. No signed blueprint means build should not start.
What is the difference between SIT and UAT in the Test phase?
System integration testing (SIT) proves that modules and external systems work together, including peak-volume and failure scenarios, usually led by technical and functional consultants with business observers. User acceptance testing (UAT) is where business process owners run start-to-finish scenarios on migrated data under real security roles and formally sign that the system is fit for purpose. Both are required: SIT without UAT can pass technically and still fail in the hands of users; UAT without SIT often discovers integration breakage too late.
What is a go-live readiness review and when does it happen?
It is the phase-gate review that confirms scope sign-off, UAT completion, performance and integration testing, the cutover plan, and the support and hypercare model before the system goes live. In Success by Design it occurs in the Prepare phase, which maps to the generic Deploy phase, and it feeds the formal go/no-go decision. It exists to catch remaining gaps before launch, when they are still cheap to fix.
How long should hypercare last after ERP go-live?
Many mid-market projects plan 4 to 8 weeks of intensive hypercare; more complex multi-site estates often need 4 to 12 weeks. Structure it: daily triage and rapid fixes in week 1, tapering to scheduled releases as severity rates fall. Exit when defect volume hits agreed thresholds, super-users handle routine issues, and critical business cycles (such as month-end close) have run cleanly, not when the first day of orders processes.
Do vendors use the same six phase names?
No, but the lifecycle maps to the same arc. Microsoft's Success by Design uses Discover, Initiate, Implement, Prepare, and Operate. SAP Activate uses Discover, Prepare, Explore, Realize, Deploy, and Run. NetSuite and Oracle Cloud guidance describe the same structured, phased rollout under their own labels. Whatever the vendor calls them, insist on the real deliverables: a signed design, SIT/UAT, a rehearsed cutover, and a hypercare plan.
Why do so many ERP implementations fail their business case?
Most failed rollouts share a few drivers: weak phase gates, inadequate change management, dirty data migrated late, over-customization of legacy habits, and go-live decisions driven by calendar rather than readiness. Enforcing Discovery and Design sign-off, real UAT, a rehearsed cutover and staffed hypercare is how a program stays out of trouble.
Should we use big bang or a phased ERP rollout?
Big bang fits smaller or single-site organizations that want a clean break and can absorb concentrated cutover risk. Phased rollout (by module, function, or site) fits mid-market and multi-entity programs that need lower risk per wave and can tolerate temporary bridge integrations. A pilot site before full roll-out is common when you need production proof before scaling. Phase gates still apply in every pattern, choosing phased does not mean skipping UAT or cutover rehearsal.