Skip to content
Get a quote

Migrate to Microsoft Project

Microsoft Project is a schedule-first PM platform whose migrations live or die on edition choice — Project for the Web on Dataverse versus the retiring Project Online versus desktop MPP — and on preserving task dependencies, baselines, and resource assignments through formats that were never designed to round-trip.

Short answer

FlitStack AI migrates projects, tasks, and timelines into Microsoft Project from 150+ project management tools. Every field is mapped to Microsoft Project's objects, history and associations come across, the Microsoft Project setup is configured alongside, and the whole migration stays reversible in one click.

By

From Your system
DestinationMicrosoft Project
150+ sources mapped into Microsoft Project

What Microsoft Project supports, and where its import tools stop

  • Organizations already running Microsoft 365 and Azure AD adopt Microsoft PPM because it slots into existing identity, Teams, and SharePoint infrastructure without requiring a separate identity provider or SSO vendor.
  • Enterprise PMOs choose it for critical-path scheduling, baseline comparison, cross-project dependencies, and resource utilization reporting that standalone PM tools cannot replicate at this depth.
  • Project Online's integration with Power BI gives portfolio-level dashboards and cost-rollup reporting that satisfies executive governance requirements without third-party BI tooling.
  • Government, financial services, and healthcare organizations select it because FedRAMP, ISO 27001, and SOC 2 compliance certifications meet enterprise procurement requirements out of the box.
Bulk APIOAuth 2.0 via Microsoft Entra ID (Azure AD). Project Online uses the same auth model as SharePoint Online, including the SharePoint authentication cookie when calling REST/OData endpoints.
Rate limitsInherits SharePoint Online's resource quotas and bandwidth throttling. The OData reporting service caps returned rows at 500 by default; standard SharePoint Online throttling responses (429/503 with Retry-After) apply.
ObjectSupportNote
ProjectsfullProjects are the top-level container in Microsoft PPM. We migrate them 1:1 including the project-level properties, start dates, calendars, and fiscal periods. Project Online stores them in the ProjectData OData endpoint; Project Server uses the CSOM ProjectContext.
TasksfullTasks with hierarchy (summary tasks and sub-tasks) are migrated with their start and finish dates, duration, and work. The task UID is preserved so downstream Dependencies resolve correctly in the destination environment.
DependenciesfullTask-to-task dependencies (finish-to-start, start-to-start, and lead/lag) are migrated as a first-class relationship. We replay the dependency chain in the destination and validate that no orphan references exist after import.
ResourcesfullEnterprise Resources including people, equipment, and material resources are migrated with their standard rates, cost per use, and calendar availability. Cost resources are mapped to the destination's cost category.
AssignmentsfullResource-to-task assignments are migrated including work hours, units, and overtime. We recalculate assignment-level work curves when the destination environment uses a different default working calendar.
BaselinesmappedBaseline snapshots are preserved as a named baseline set on each project. Some destination platforms store baselines as separate time-series records rather than as named snapshots; we map accordingly and flag any truncation.
MilestonesfullMilestone tasks are identified by zero duration and are migrated with their milestone date. We preserve any milestone-specific notes or custom properties attached to the milestone task.
Custom FieldsmappedEnterprise custom fields (lookup tables and flag, date, text, and number types) are migrated where the destination schema supports them. Local project-level custom fields are mapped to the equivalent destination entity property or stored as extended attributes.
PortfoliosmappedPortfolio grouping and program association require Plan 5 (Project Online) or Project Server. We map portfolio relationships using a cross-reference table and flag if the destination lacks a portfolio layer.
TimesheetsmappedTimesheet data in Project Online is stored separately in the Workflow and Timesheet tables. We extract actual work entries and map them to the destination's time-tracking module, noting that historical locked periods may not be editable.
Issues and RisksmappedIssues and Risks are project-level entities that some tiers expose via the CSOM but not via OData. We attempt API extraction first and fall back to SharePoint list exports when the API path is gated by the subscription tier.
DocumentsmappedProject documents are stored in SharePoint libraries attached to the PWA site. We extract documents and re-upload them to the destination SharePoint or equivalent document management system, preserving version history where the API supports it.

The Microsoft Project migration guide

Why teams migrate to Microsoft Project

The four shapes a Microsoft Project migration takes, and why edition choice — not source platform — is the first decision that matters.

Microsoft Project is a project management product developed and sold by Microsoft since 1984 — the company's third Windows-based application and the long-running default for Gantt-driven scheduling in the enterprise1. Its proprietary file format is .mpp, and from 2015 to 2020 it was the most popular project management application according to Project Management Zone1.

The typical customer profile splits across three editions whose migration mechanics diverge sharply: Microsoft Project Desktop (Standard or Professional, MPP files, single-planner or local workgroup); Project Online (SharePoint-backed Project Web App, on a retirement trajectory after Project for the Web took over the modern roadmap); and Project for the Web / Microsoft Planner (Dataverse-backed, integrated with Power Apps, Power Automate and Teams)1.

Licensing is tier-based — Project Plan 1 at $10/user/month for the lightweight web experience, Plan 3 at $30 including the desktop client, and Plan 5 at $55 for portfolio management and resource pools. Project for the Web was set to retire on August 1, 2025, folding into the new Microsoft Planner1.

The shapes of migration that land on Microsoft Project fall into four patterns. First, edition modernisation — teams moving from Project Online or Project Server PWAs onto Project for the Web / new Planner. Second, on-prem-to-cloud moves from Project Server installations onto Project Online or Project for the Web, typically driven by SharePoint version end-of-life11.

Third, consolidation onto Project from Asana, Smartsheet, Wrike, Jira or Monday, where teams want stronger critical-path scheduling and resource levelling than work-management tools provide148. Fourth, desktop-to-server moves where a team standardises a collection of .mpp files into a single PWA or Project for the Web tenant for resource pool sharing and Power BI reporting.

What makes migrating to Microsoft Project easier than the category average is the maturity of the file ecosystem — desktop reads MPP, MPT, MPX, XML, XLSX, CSV and ASCII text, and the Import Wizard can map columns by hand or by saved map5357.

What makes it harder is the edition fragmentation: Project for the Web caps custom fields at ten, has no formula support and no cross-project field reuse4344, while Project Online's programmatic surface area is narrow and undocumented for many fields practitioners actually need26.

Schedules, baselines, dependencies and resource assignments do not move cleanly between editions without a tool that understands the underlying object model. Teams that pick the right edition first finish on time; teams that pick the import tool first do not.

Pick the right edition first and the right import path second. Teams that do this in reverse finish late.

The Microsoft Project data model you need to map into

Tasks, Resources, Assignments, Calendars, and Baselines — the destination schema decoded across the three editions you might be landing on.

Microsoft Project's object model is documented in the VBA reference — the Application sits at the root, Projects under it, and within each Project sit Tasks, Resources, Assignments, Calendars, WorkWeeks and Subprojects36. Project for the Web reshapes the same concepts onto Dataverse tables, while Project Online exposes them through the Project Server Interface (PSI) and CSOM2226.

Before you can map a field on the source side, you need to know exactly which destination object the row belongs on, what fields it requires, and which value will serve as its upsert key. The table below summarises the objects you will touch in a Microsoft Project migration.

ObjectWhat it storesRequiredTier
ProjectThe container — schedule, calendar, baseline, settingsName, start or finish dateAll editions
TaskWork items in a hierarchical outline (summary + leaf)Name, duration; outline level for hierarchyAll editions
Summary TaskRolled-up parent tasks; computed from childrenOutline structure (level/indent); auto-calculatedAll editions
SubprojectLinked external Project inserted into the masterSource file path or inserted Project referenceDesktop + Project Server
ResourceWork, Material, Cost — people, equipment, expensesName, Type (Work/Material/Cost)All editions
AssignmentTask ↔ Resource link with Work and UnitsTask ID, Resource ID, Units, WorkAll editions
Task DependencyFS / SS / FF / SF links with lagPredecessor, Successor, Type, LagAll editions
CalendarProject calendar + Resource calendars; working/non-working timeName, base calendar; WorkWeek and exception daysAll editions
BaselineSnapshot of dates/work/cost at a point in timeSet after schedule build; up to 11 baselines (Baseline + Baseline1-10)Desktop, Project Online
Custom FieldText1-30, Number1-20, Date1-10, Flag1-20, Cost1-10, Outline Code1-10 on desktop; max 10 fields on Project for the WebType fixed at creation; cannot be changed laterDesktop / PWA: ~100 fields; Project for the Web: 10

Tasks use a numeric Unique ID (UID, stable for the life of the project) and a positional ID that renumbers when rows shift; Resources use the same scheme. There is no platform-wide GUID across projects on the desktop — Project.GUID is per-file. On Project for the Web / Dataverse, every record gets a Dataverse id (GUID) that is the canonical primary key27.

When you import on the desktop, the Import Wizard does not upsert against a stable key — it appends to the active project or creates a new one57. For upsert semantics, use the PSI/CSOM (Project Online) or the Dataverse layer (Project for the Web), upserting against the Dataverse id or an Alternate Key defined in advance1827.

Custom field types determine validation and storage. On Project Desktop you get a fixed catalogue of typed slots (Text1-30, Number1-20, Date1-10, etc.) renamed via Project → Custom Fields, with optional lookup tables and formulas4450. On Project for the Web you can create at most 10 custom fields per project, only the types listed below, and you cannot change a field's type after creation4344.

Field typeLimitNotes
Text (desktop) / Text (P4W)Text1-30 on desktop; up to 255 chars; 10 fields max P4WCustom lookup tables supported on desktop, not on P4W
NumberNumber1-20 on desktop; rollups: Max/Min/Sum/AverageType immutable after creation44
DateDate1-10 on desktop; Start1-10 / Finish1-10Time-of-day stored; respect Project calendar
DurationDuration1-10Stored in minutes internally; display unit configurable
CostCost1-10Currency-formatted; uses project currency setting
Flag (Yes/No)Flag1-20Boolean; rollups: AND/OR/Count
Outline CodeOutline Code1-10Hierarchical lookup; not supported in P4W
FormulaAvailable on desktop / Project Online onlyNot supported in Project for the Web44
Custom field count (Project for the Web)10 hard cap per projectCross-project field reuse is not currently supported43

Relationships in Project are modelled as Task Dependencies — Finish-to-Start (FS, the default), Start-to-Start (SS), Finish-to-Finish (FF) and Start-to-Finish (SF) — with positive or negative lag expressed in time units or as a percentage of predecessor duration135. Resources attach to tasks via Assignments carrying Units, Work, Actual Work and Remaining Work26.

Project Online imposes a 25 GB quota per Project Web App site, separate from SharePoint Online limits34. Subprojects (master/insert) allow nested project hierarchies on desktop and Project Server but are not supported in Project for the Web11.

The single most-important detail for any practitioner mapping into Project: task type (Fixed Units / Fixed Duration / Fixed Work) drives how Work, Duration and Units recalculate during import — get the project default wrong and your durations will silently drift after the load.

Pre-migration prep — the work before you touch Microsoft Project

What must be true on the source, the destination, and across the team before the first MPP, XML or CSV hits the Import Wizard.

The single best predictor of a clean Microsoft Project migration is how much work you do on the source side before the first file is opened. Most teams discover this on day two when a 1,200-task plan imports with the wrong calendar, no baseline and resource assignments that arrived as plain text — every one of which traces to a missing pre-flight step.

Most Microsoft Project migration failures trace to three pre-flight gaps: wrong calendar, wrong task type default, and no resource pool plan.

Treat the source export as raw material that needs to be shaped to Project's expected formats — durations in consistent units (hours, days or weeks; pick one), dates rewritten to a culture-stable format, resource names resolved against the target Resource sheet, and outline levels expressed as integers your WBS column can read.

Source-side prep

  • Audit and dedup the source project list before export — duplicate task names will not collide (Project allows them), but duplicate resource names across the Resource sheet break Assignment rollups and Cost calculations.
  • Standardise duration units — pick hours or days for the entire dataset and convert. Project stores duration in minutes internally and infers display units from the import; mixed units in one file produce silent errors60.
  • Re-encode CSV files as UTF-16 LE with BOM or legacy ANSI — recent Project updates broke parsing of UTF-8 and ANSI CSV, and the workaround is to save as Unicode in Excel before importing71.
  • Normalise dependency notation — Project accepts 5FS+2d, 5SS, 5FF-1d etc., but rejects free-form text. If the source exports Task 5, FS, 2 days you must transform before import.
  • Decide what is in scope for historical data — actual work, actual start, actual finish, % complete and baselines must be imported on a separate pass after the schedule shape lands, or auto-scheduling will overwrite them.

Destination-side prep

  • Pick the edition and tier first — Project for the Web caps custom fields at 10 and lacks formulas4344; Project Online has a 25 GB PWA quota34; desktop has no shared resource pool unless you wire Project Server. Get this wrong and you re-do the migration.
  • Create the Project calendar and Resource calendars before importing — set working hours, exceptions, and base calendar (Standard / 24 Hours / Night Shift). Imports use the project calendar to translate Duration into Start/Finish, and getting this wrong moves every date.
  • Pre-create every custom field on Project Desktop or Project for the Web with the right type — type is immutable after creation44; the only fix is delete-and-recreate, which loses any data already loaded.
  • Provision the Resource sheet or Resource Pool before importing assignments — assignments to unresolved resources are silently dropped or, worse, create new resources with the source's text representation as the name.
  • Set Auto-Schedule vs Manually Scheduled as the project default before import — Manually Scheduled tasks honour the dates you load; Auto-Scheduled tasks recalculate from constraints and dependencies, which can reshuffle imported dates.

People prep

Cutover only works if humans cooperate. Lock a source-system freeze window — typically 24 to 72 hours — and communicate it to every project manager who owns a plan. Train PMs on the destination's scheduling defaults (Auto-Schedule behaviour, baseline workflow, time tracking entry) before go-live, not after.

A pilot migration of two or three representative plans — one simple, one complex with dependencies, one with significant financial tracking — surfaces 80% of the rollout's edge cases in week one. A full rollout typically takes four to eight weeks depending on the number of active projects, plan complexity, and reporting standardisation.

Import mechanisms: UI wizard, file formats, and programmatic loads

Multiple paths in — the desktop Import Wizard, the Project for the Web migrator on Dataverse, and the Project Online PSI/CSOM. Picking the wrong one is how migrations stall.

Microsoft Project exposes several load paths and the right one depends on edition, dataset shape, and whether you need re-runnable upserts. The desktop Import Wizard covers file-based loads (MPP, MPT, MPX, XML, XLSX, CSV, TXT). The Project for the Web Dataverse stack handles modern, web-native loads via Power Apps / Power Automate or direct Dataverse writes. The Project Online PSI/CSOM surface handles programmatic loads against PWA sites.

Desktop Import Wizard (Project Standard / Professional)

On the desktop, the Import Wizard runs from File → Open → [file type] or File → New → New from Excel workbook75. Supported source formats are Project Plan (.mpp), Project Template (.mpt), Project Exchange (.mpx, read-only in modern versions), Project XML (.xml), Excel Workbook (.xls, .xlsx, not .xlsm), tab-delimited text (.txt), comma-separated values (.csv) and XPS535797.

The wizard walks Task Mapping, Resource Mapping and Assignment Mapping pages where each source column is mapped to a Project field by hand or via a saved map57. You choose New project, Append the data to the active project, or Merge the data into the active project.

There is no documented row-count cap — practitioner reports describe successfully importing schedules of 5,000+ tasks — but plans above roughly 1,000 tasks tax the default cache and undo limits, both of which should be raised before the load (cache to 100+ MB, undo to 99).

The right call: desktop Import Wizard for any file-format source under a few thousand tasks, single-planner migrations, or when you are consolidating a folder of MPP files into a master via Insert Subproject.

Project for the Web — Dataverse

Project for the Web stores everything in Dataverse — the same backend used by Dynamics 365 — and is loaded via the Dataverse layer with the CreateMultiple / UpdateMultiple / UpsertMultiple bulk actions18. Bulk operations are throttled by Dataverse service-protection limits — honour the Retry-After response when throttling kicks in rather than calculating rates yourself19.

Tables you write into include msdyn_project, msdyn_projecttask, msdyn_projectteam (resources), msdyn_resourceassignment and msdyn_projecttaskdependency. Power Automate, Power Apps and FluentPro Project Migrator all sit on this same Dataverse layer and are commonly used in the migration corner of the ecosystem151.

Project Online — PSI and CSOM

Project Online exposes the Project Server Interface (PSI) and the CSOM against the PWA site2226. Practitioners commonly report needing the AssignmentTimephasedDataSet to pull resource hours per day, which requires CSOM or OData against /_api/Projectdata26.

Throughput patterns from the Dynamics 365 service-protection guidance carry over: use multiple threads with Retry-After backoff, distribute load across multiple service principals if a single one hits per-user limits, and prefer batch operations over per-record calls19.

Third-party migration tools

FluentPro Project Migrator and FluentBooks, Relokia Migration Wizard, Birdview PSA's migration service and PPM Express all run on top of the load paths above. Project Migrator specifically lists Asana, Smartsheet, Planner, Project Online and Project for the Web as supported routes151.

Mapping your data into Microsoft Project

The longest section — because schedule shape, dependencies, baselines and resource assignments are where almost every PM migration that fails actually breaks.

Mapping is where every PM migration earns its scars. The decisions you make in the field-mapping spreadsheet determine whether the critical path matches the source on day two, whether time-tracking entries reconcile on day five, and whether PMs trust the schedule on day thirty.

Work object by object, top to bottom of the import order: Calendar first (so dates translate correctly), then Resources (so assignments can land), then Tasks with outline structure, then Dependencies, then Assignments, then Baselines, then Actuals.

Project hierarchy and task dependencies

Project hierarchy in Microsoft Project is expressed as an outline — summary tasks at outline level 1, sub-tasks at level 2, sub-sub-tasks at level 3, with no formal cap on depth. When importing from a flat source like Excel or CSV, include an explicit Outline Level column with integer values, or include a numeric WBS column (1, 1.1, 1.1.1) that the Import Wizard can use to generate the outline structure69.

Without one of these columns the wizard imports everything as siblings at level 1 and Summary Tasks are not generated. Add Outline_Level to your CSV as the first preprocessing step.

Source → Microsoft Project Task mapping
SourceDestinationNote
task_name / titleNameRequired; no uniqueness constraint
outline_level / wbsOutline Level / WBSDrives summary task generation — required for hierarchy69
durationDurationStored in minutes; pick consistent unit (e.g. days) and let display format infer
start_date / planned_startStartAuto-Schedule will recompute unless task is Manually Scheduled
finish_date / planned_endFinishSet Manually Scheduled if you need imported finish to stick
predecessor task IDsPredecessorsNotation: 5FS+2d, 5SS, 5FF-1d; reject free-form text
milestone flagMilestone (Yes/No)Tasks with Duration=0 auto-flag; otherwise explicit field
constraint type + dateConstraint Type / Constraint DateASAP, ALAP, MSO, MFO, SNET, SNLT, FNET, FNLT — pick deliberately
task notes / descriptionNotesRTF on desktop; plain text on Project for the Web84

Task dependencies on import require the predecessor task to already exist in the same project — a common failure mode for streaming imports where dependencies arrive before their predecessor row3. Two strategies: (1) sort the source by Outline Level and within-level by ID so predecessors load first, or (2) make a second pass after all tasks are loaded that only writes the Predecessors column.

Resources and assignments

Source → Microsoft Project Resource mapping
SourceDestinationNote
resource_name / assigneeNameMust be unique; mismatches create duplicates silently
resource_typeTypeWork (people, hourly), Material (consumables), Cost (one-time)
email / upnEmail AddressUsed for Outlook task assignment and Project for the Web user resolution
calendar_idBase CalendarPer-resource calendar overlays the project calendar
max_units / capacityMax Units1 = full-time; 0.5 = half-time; affects levelling
standard_rateStd. RateCurrency/time; e.g. $75/hr

Assignments require Task ID and Resource ID to both resolve. Source files that carry the resource as a free-text string (e.g. "Jane Doe") need a lookup-and-rewrite pass against the destination Resource sheet before assignment rows are imported, or assignments will create duplicate resources or fail silently.

Time tracking — Work, Actual Work, Remaining Work

Microsoft Project models time tracking on assignments via three core fields: Work (planned), Actual Work (logged), and Remaining Work (computed or entered). On the desktop, Actual Work can be imported via the wizard, but only if the import target field is mapped explicitly — practitioners frequently report imports where Outline and Tasks land but Actual Work shows 0 hours because the column was not in the import map60115.

Project Online and Project for the Web add timesheet entries (AssignmentTimephasedDataSet for the per-day breakdown) — these require CSOM or the OData _api/Projectdata path to read or write26. If you need per-day time history (not just totals), plan to either re-key in the destination or use a third-party tool that wraps the timesheet load.

Comments and attachments threading

Microsoft Project Desktop does not have native comment threads — it has the Notes field per task and per resource, accepting RTF on desktop and plain text everywhere else84. Project Online layers PWA discussion threads via SharePoint, and Project for the Web / new Planner uses Task chat (the modern replacement for legacy task comments) for threaded conversation133.

If you are migrating from a tool with rich comment threads (Asana, Monday, ClickUp), the practical mapping is: collapse the source comment thread into the destination Notes field as a chronological text blob, optionally with a SharePoint or Teams deep link to the original. Microsoft retired legacy Planner task comments in mid-January 2026 — migrations into Planner / Project for the Web must use Task chat going forward8.

Attachments do not move inline through the Import Wizard. The supported path is to upload the file to the SharePoint document library backing the PWA (Project Online) or to the Dataverse msdyn_projectattachment table / Teams files (Project for the Web), then add a link in the task's Notes or Hyperlink field93102.

Custom workflow status and recurring tasks

Microsoft Project does not have a true Kanban-style workflow engine — the closest equivalents are: (1) the Status field, which is computed by Project from %Complete and Status Date and cannot be customised45; (2) a Text field (Text1 through Text30 on desktop) renamed to Status and populated with a lookup table of custom values45; and (3) the Project for the Web Bucket field for board-style grouping44.

If your source has a state machine like To Do → In Progress → Blocked → Done, the cleanest mapping is to import the state into a renamed Text field with a lookup table, then either drive %Complete from it via a formula (desktop only) or leave the two parallel as a manual reporting field.

Recurring tasks are created on the desktop via Project tab → Insert Recurring Task and stored as a single parent task with auto-generated children for each occurrence. There is no bulk-import path for recurrence rules — you import the parent and let Project generate the instances, or pre-expand the recurrence in the source CSV and import every instance individually.

Baselines and snapshots

Microsoft Project Desktop and Project Online support up to 11 baselines (Baseline plus Baseline1 through Baseline10), each storing a frozen snapshot of Start, Finish, Duration, Work and Cost for every task and assignment at the moment the baseline was set134. Baselines do not auto-import — once the schedule lands, run Project → Set Baseline to capture the current state, then any later actuals work shows as variance from the imported plan.

If you need to preserve baselines from the source, the only supported path is to write to the Baseline Start, Baseline Finish, Baseline Duration, Baseline Work and Baseline Cost columns explicitly during import — these are all individually mappable in the Import Wizard but absent from default import maps.

Audit trail, ownership and original timestamps

Standard Created, Created By, Modified and Modified By are platform-managed on Dataverse and SharePoint backends — they cannot be overwritten during a normal bulk import. Dataverse does expose overriddencreatedon for the create timestamp on a per-record basis when the calling user has the right privileges, but modifiedon and modifiedby always reflect the import job's identity113.

If you need to preserve the original audit trail, the pattern is to create two custom fields per object — Legacy Created Date (Date1) and Legacy Created By (Text1) — and populate them from the source export. Owner/Assignee mapping during import only succeeds if the destination user exists in the tenant at the moment of import; assignments to unresolved users either fail silently or land against the import job's principal.

PM-specific: Power BI, Roadmap, Teams integration

Power BI reporting against Project data is configured after the data lands — the OData feed for Project Online is /_api/Projectdata; for Project for the Web it is the Dataverse connector. Roadmap and the Project / To Do / Planner shared task list inside Teams both refresh automatically once the underlying projects exist, but they are read-mostly surfaces — task-level edits there do not propagate back into Project148.

The pitfalls that derail Microsoft Project migrations

Nine specific failure modes — ranked by impact, each tied to the exact Microsoft Project mechanism that breaks.

Validation and cutover

What to verify after the import job, in what order — and how to fail safely when something is wrong.

Validation is the bridge between the import finishing and PMs being allowed to schedule against the new plan. Practitioners recommend a three-stage validation: a pilot of 2 to 3 representative projects with PM spot-checks, the full load with real-time monitoring of task counts and dependency integrity, and a 30-day post-migration audit on actuals and baselines.

The most reliable signal is having the project's owning PM verify their own schedule — they know what the critical path should look like better than any reconciliation script.

Build a reconciliation queries spreadsheet that compares source and destination on the counts below. Anything outside a 0.5 percent variance gets investigated before PMs get edit access.

  • Total tasks per project vs source — including summary tasks; mismatches usually trace to outline-level parsing gone wrong.
  • Total dependencies per project — count Predecessor links and compare; dependency drops are the most common silent failure during Excel/CSV imports.
  • Total assignments per project — and total Work hours summed across all assignments; a non-trivial hour variance usually signals unresolved resources.
  • Critical path length (project Finish - project Start) — should match the source to within a calendar day; if it doesn't, calendar or task-mode mismatches are in play.
  • Baseline coverage — count tasks with a non-null Baseline Start; this should be 100% for projects you baselined before migration, 0% for projects you intend to re-baseline after.
  • Resource roster — count distinct resources on the Resource sheet; any duplicates indicate the resource-name lookup transform missed cases.
  • Per-resource Work totals — GROUP BY Resource on Assignment Work and confirm against the source's capacity planning.

On top of reconciliation, run a manual spot-check: pick 10 random tasks across the most complex projects and verify Name, Duration, Start, Finish, Predecessors, Assignments and %Complete against the source UI. Pick three high-complexity dependency chains and trace each predecessor link visually on the Gantt chart. If a non-trivial discrepancy shows up in three or more of the 10, halt the load, fix the root cause, and re-import the affected projects.

Dataverse-backed Project for the Web supports record restoration: deleted Dataverse table records can be restored from the recycle bin via the Power Platform admin centre for a limited window (usually 30 days)104. Project Desktop has no native undo across a closed-file boundary — close the file after import and the undo stack is gone, which is why every desktop migration should keep the original MPP file as the rollback artefact.

The real rollback strategy remains: export every source plan to MPP and XML before the import starts, stamp every imported task with an Import Batch ID custom Text field, and if catastrophe strikes, bulk-delete by that batch ID and re-import from the cleaned source.

Cutover sequencing: (1) source goes read-only and PMs are notified; (2) final delta export captures everything that changed during the pilot window; (3) delta is imported; (4) reconciliation runs; (5) PMs get edit access and a 48-hour hyper-care window with the migration lead on call; (6) baselines are set on the destination after PMs sign off on the schedule; (7) source decommission is scheduled for 30 to 90 days out, never the same day.

Migration partners and tools

Microsoft-certified consultants, specialist migration shops, and the Dataverse/iPaaS layer — what each is good for and how to choose.

The Microsoft Partner Network tiers consultants by competencies — Project Management is a recognised competency and there is a publicly-searchable Partner Directory. Practices that specifically deliver Project Online and Project for the Web migrations include Katalyst Partners (which lists 1,000+ Project Server migrations), Progent, PPM Express, Birdview PSA, and Aelum Consulting in the ServiceNow corner of the market for teams moving off Project Online entirely.

On the specialist migration-tool side, FluentPro ships Project Migrator and FluentBooks specifically for project-management platform migrations and is listed in the Microsoft Marketplace; it supports Asana, Smartsheet, Planner, Project Online, and Project for the Web with built-in object mapping151.

Relokia Migration Wizard covers MS Project to common PM destinations and exports Groups, Tasks (with Comments and Custom Fields), Task Dates, Created Date, and Users — practitioners note that MS Project does not have native task comments and Relokia synthesises one from the Notes field instead.

On the ETL and iPaaS side, Fivetran, Airbyte, Stitch, Workato and MuleSoft all have Microsoft Dataverse and Microsoft 365 connectors. Their role in a Project migration is rarely the migration itself — it is the staging layer that lands source data into a warehouse, the transformation layer that converts resource names and resolves dependencies, and the ongoing-sync layer that takes over once the one-time migration is complete.

Microsoft's own implementation guidance for Dynamics 365 / Power Platform — which Project for the Web shares as a backend — recommends a sandbox-first environment strategy, with separate Dev, Test and Production tenants and a tested promotion pipeline74.

Managed-migration cost ranges vary widely. PPM Express advertises predictable enterprise pricing starting around $7,200/year for unlimited users, and partners scoping a migration service typically price by project rather than by seat.

A clean desktop-MPP consolidation of 25 to 50 plans without resource pools usually lands in the $5,000–$15,000 range; an enterprise Project Online to Project for the Web move with custom fields, baselines, timesheets and Power BI report rebuilds typically runs $40,000–$150,000 depending on plan count and historical depth148.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Microsoft Project migrations and handles the field mapping, edition-fit assessment, calendar and resource pool setup, baseline preservation, and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on plan count and source platform, with separate line items for historical actuals depth and timesheet preservation so the scope is transparent before signature.

This is one of several legitimate paths — the right choice for any given team depends on whether they want a Microsoft Partner Network consultancy, a specialist tool like FluentPro Project Migrator, an iPaaS-first approach, or an end-to-end managed migration. [Explore FlitStack →](/contact)

Microsoft Project migration checklist

An exhaustive, phased punch list for moving an existing project portfolio onto Microsoft Project — from edition selection through cutover to source decommission. Typical timeline: 6–16 weeks.

0. Decide & Plan11 tasks
  • Document the migration objective and the trigger event in one paragraph. Capture why the move is happening now (tool consolidation, Project Online retirement notice, license consolidation, M&A) so later scope debates can be settled against the original intent.
  • Decide the target Microsoft Project edition: Project for the Web, Project Online, Project Server, or Project desktop (Standard / Professional 2024). Project for the Web is the modern Dataverse-backed edition; Project Online is the legacy SharePoint-backed cloud edition with a retirement trajectory; Project Server is on-prem; desktop is file-based MPP/MPP. Each edition has a different data model and a different migration mechanism.If skipped: Building a transform pipeline for one edition then discovering the org licensed a different one forces a full rework of the mapping spreadsheet and the load scripts.
  • Pick the Project plan tier: Project Plan 1, Project Plan 3 or Project Plan 5. Plan 1 covers Project for the Web basics; Plan 3 adds the desktop client and Roadmap; Plan 5 adds portfolio analysis and demand management. Map required features to plan before any purchasing.If skipped: Provisioning Plan 1 then discovering a Plan 5 feature is mandatory forces a mid-migration license uplift and a re-provisioning of every user.
  • Define the in-scope object set: Projects, Summary Tasks, Tasks, Sub-tasks, Resources, Assignments, Baselines, Custom Fields, Attachments, Conversations and Roadmaps. List each object explicitly with an in-scope or out-of-scope flag. Treat Conversations, Baselines and historical timesheet entries as separate decisions from Tasks.If skipped: Implicit scope expands mid-project as stakeholders discover missing data, blowing the timeline.
  • Decide the historical-data window: how many years of source projects, tasks, time entries and attachments come across. Pair each in-scope object with a date cut-off. Older projects can be archived as read-only MPP / XML files instead of imported into the destination.If skipped: Importing unbounded history inflates Dataverse storage on Project for the Web and slows every Roadmap and Power BI view.
  • Confirm the EU Data Boundary position for the chosen edition before provisioning. Project for the Web inherits the Dataverse region of the Microsoft 365 tenant. EU customers needing residency must verify the tenant is in an EU region; relocation post-provision is not a self-service action.If skipped: A US-region tenant holding EU personal data breaches GDPR Article 44 obligations from cutover onward.
  • Identify legal and compliance constraints that gate the cutover. Capture GDPR data-processing addenda, HIPAA BAA requirement, SOC 2 evidence needs, customer contracts that name the source platform, and any retention policies that change on cutover.
  • Assign a single accountable migration owner (DRI) and a named delegate. One person signs off each phase. Cross-functional input is welcome; ownership is not shared.
  • Document explicit success criteria for cutover. Examples: every active task has the same Start, Finish, % Complete, Resource and Predecessor in destination as source; every Baseline survives; every attachment opens; every Roadmap reflects the new project IDs.If skipped: Without written criteria, sign-off becomes a negotiation instead of a verification step.
  • Set the target cutover window, the source-system freeze date, and a no-go fallback date. Pick a window that avoids fiscal close, sprint boundaries and known release freezes for downstream teams that consume Project data via Power BI or SharePoint.
  • List explicit out-of-scope items in writing. Common exclusions: PSI/CSOM custom code, archived projects beyond cut-off, source-system Power Automate flows, legacy Project Online PWA configuration objects with no Project for the Web equivalent.
1. Pre-Migration Prep27 tasks
  • Export source project counts, task counts and resource counts as a numeric baseline. Capture counts per project, per status, per resource. Save the export as the reconciliation reference for Phase 6.If skipped: Without a baseline, post-cutover deltas can be explained away as "normal" instead of investigated.
  • Run dedup analysis on source tasks and resources using a stable match key. Match tasks on (project_uid, task_uid) where present, and resources on email. Resolve duplicates in the source while you still have its tooling.If skipped: Duplicates merged after import require manual cleanup against destination Dataverse GUIDs that did not exist at source time.
  • Normalize resource email casing and verify each resource email resolves to a real Microsoft 365 mailbox. Project for the Web binds resources to Microsoft 365 identities; tasks assigned to bounced or unlicensed mailboxes need reassignment before cutover.
  • Standardize date values to ISO-8601 with explicit timezone before export. Project stores dates against the project calendar and resource calendar; mixed-format source dates surface as off-by-one-day errors on Start, Finish and Deadline fields.If skipped: Date imports silently shift days at the date-line, producing wrong deadlines on hundreds of tasks.
  • Identify and resolve tasks missing required fields (Name, Duration or Start). The Project Import Wizard and the Power Apps Dataverse import both fail rows with missing required fields. Pre-fill or drop the row before load.If skipped: Import jobs abort partway when a required field is unset, leaving the project plan in a half-loaded state.
  • Audit source custom field count against the Project for the Web 10-custom-field-per-project hard cap. Project for the Web caps custom fields at 10 per project. Project Online and Project desktop allow up to 10 of each type (Text1-Text30, Flag2-Flag20, Number1-Number20, Date1-Date10). Rationalize source fields against the destination cap before mapping.If skipped: A source plan with 30 custom fields cannot land on Project for the Web without dropping or concatenating 20 of them.
  • Audit source field types: text, number, date, flag, duration, cost, finish, start and outline code. Project custom field types are immutable after creation. Decide the destination type per source field in this phase, not at load time.If skipped: Creating a Text field on the destination then needing a Number means deleting and rebuilding, losing every value already loaded.
  • Document and resolve any encoding issues in CSV exports (non-UTF-8 text, BOM markers, smart-quote artefacts). Recent updates to Project desktop introduced a CSV parsing regression where UTF-8 and ANSI files fail to open; verify the working format on the destination version before relying on it.If skipped: An export that opens fine on Project 2019 may fail silently on Project 2024 after the late-2025 CSV parsing change.
  • Audit source recurring-task definitions and capture the recurrence pattern per recurring task. Recurring tasks expand to individual task rows on save in source. Capture the original recurrence so it can be rebuilt via Insert Recurring Task on the destination.
  • Provision the Microsoft 365 tenant (or confirm the existing tenant) in the correct Dataverse region. Project for the Web is built on the same Dataverse the tenant uses for Dynamics 365. Region is set at tenant creation; relocation later requires a tenant-to-tenant move.If skipped: An EU-resident customer provisioned in a US region must move tenant-to-tenant later, costing a second migration.
  • Assign Project Plan licenses (Plan 1, Plan 3 or Plan 5) to every user before user load. License assignment must precede the user's first sign-in to Project for the Web for the Dataverse user record to provision correctly.
  • Provision a separate sandbox Dataverse environment for the dry run. Power Platform admin → create a non-production environment in the same region as production. Project for the Web installs into the environment as a managed solution.If skipped: Testing in the production environment exposes incomplete data to end users before sign-off.
  • Configure the project calendar and the default resource calendar on the destination. Calendars affect every Start, Finish and Duration value. Decide the working week (Monday–Friday vs. custom), working hours, holidays and the default base calendar before any task lands.If skipped: A wrong calendar shifts every task end date by the difference between source and destination working hours.
  • Set the default scheduling mode per project: Auto Schedule or Manually Scheduled. Auto-scheduled tasks recompute Start and Finish from predecessors and resource calendars; Manually Scheduled tasks honour the loaded dates. Pick the mode that matches the source semantics before load.If skipped: Loading Manually Scheduled source data into an Auto Schedule destination shifts hundreds of dates on import.
  • Create the destination custom fields on every project template before any import. Decide field name, type (Text, Number, Date, Yes/No), formula and lookup table per field. Stay under the 10-custom-field cap on Project for the Web; under the per-type cap on Project Online and desktop.If skipped: Importing into a field that does not yet exist silently drops the column's data on most edition flows.
  • Decide and configure the Baseline strategy on every project. Project supports Baseline through Baseline10. Decide whether the source's current plan becomes the destination Baseline 0 ("original plan") or whether a fresh Baseline is captured after load.If skipped: Without a captured Baseline, Earned Value Management reports lose their reference point.
  • Configure the Resource Pool: enterprise resources (Project Online / Server) or per-project resources (Project for the Web / desktop). Enterprise resources are shared across projects; per-project resources are scoped to one plan. Decide which model the destination uses and provision accordingly.
  • Provision destination users in Microsoft Entra ID with the correct role: Project Manager, Team Member or Resource Manager. Project for the Web reads role from the Dataverse security role. Project Online uses the PWA permission mode (categories or SharePoint groups). Match source roles intentionally; do not default everyone to Project Manager.If skipped: Over-assigning Project Manager rights bypasses approval flows and exposes plan edits to the wrong audience.
  • Configure Power Automate flows and Power Apps integrations in disabled or paused state until cutover. Flows that fire on Dataverse row creation will trigger on every imported task and assignment. Keep them off until validation completes.If skipped: Status-change flows fire on every imported task, generating a flood of notifications and Teams pings to end users.
  • Disable destination email notifications for users involved in the import. Bulk task creation generates a notification per assignment per subscriber by default in Project for the Web and via Teams in Tasks by Planner and To Do.
  • Generate an application user (service principal) for the import in Power Platform admin. Use a dedicated service principal, not a personal admin, so post-cutover audit logs show migration writes separately from human edits.If skipped: Mixing migration writes with admin writes makes Dataverse audit-log triage impossible after cutover.
  • Configure Microsoft Teams integration: install the Project app and Tasks by Planner and To Do where teams will consume tasks. Tasks by Planner and To Do shares the Project for the Web task list with Teams members; decide which channels the projects pin to before load.
  • Configure Power BI workspace and the Project for the Web content pack for reporting continuity. Source dashboards do not transfer; the Power BI workspace is the rebuild target. Provision it before cutover so reports can be re-pointed without delay.
  • Announce the source-system freeze window to every project manager and resource. Include the exact start time, the read-only date and the destination-go-live time. Repeat 72h, 24h and 1h before freeze.
  • Schedule destination training segmented by role: project manager, team member, resource manager and PMO admin. Auto Schedule vs Manually Scheduled, Critical Path Method, Baselines and the Roadmap view each need their own session. Run them in the week before cutover so the muscle memory is fresh.
  • Designate first-responders for the 48 hours after cutover. Name two on-call admins per timezone. Publish a single intake channel for issues so triage is centralized.
  • Pre-write the cutover go/no-go checklist and circulate it to every stakeholder. Items: source frozen, exports complete, sandbox sign-off in hand, destination Power Automate flows paused, rollback plan ready.
2. Source Export14 tasks
  • Export every in-scope project as MPP, MPX or XML using the source platform's native Save As or Export Wizard. MPP preserves the most fidelity but is binary; XML is the recommended interchange format because it round-trips cleanly between Project versions and external tools.If skipped: Exporting only to CSV loses Baselines, calendars, dependencies and formula custom fields that the binary formats preserve.
  • Export the task list per project as CSV / XLSX with Outline_Level, Name, Duration, Start, Finish, % Complete, Actual Work, Predecessors and every custom field column. Outline_Level is required for Project's import wizard to rebuild the Project → Summary Task → Task → Sub-task hierarchy.If skipped: Without Outline_Level, the imported plan flattens every task to level 1 and the hierarchy is rebuilt by hand.
  • Export task dependencies (predecessor / successor pairs) with the dependency type and lead/lag. Capture (from_task_uid, to_task_uid, type) where type is FS, SS, FF or SF, plus the lead/lag value in days. Project's Predecessors column accepts these in shorthand (e.g. 12FS+2d).If skipped: Discarding lead/lag values drops every "start two days after the predecessor finishes" link and shifts the Critical Path.
  • Export the resource list per project (or the enterprise resource pool) with Name, Email, Standard Rate, Overtime Rate, Max Units, Group and resource calendar. Resources land in Project for the Web's resource table or the Project Online Enterprise Resource Pool; the email column is the join key to Microsoft Entra users.
  • Export task assignments separately from tasks with task_uid, resource_email, Units, Work and Actual Work. Assignments are a junction object in Project's data model. The split lets you load tasks before resources and then link them via assignment rows.If skipped: Mixing assignments into the task export forces a row per (task, resource) and breaks the task uniqueness needed for upserts.
  • Export Baselines (Baseline 0 through Baseline 10) as separate columns per task: Baseline_Start, Baseline_Finish, Baseline_Duration, Baseline_Work, Baseline_Cost. Baselines capture the original-plan snapshot for Earned Value Management. Project for the Web supports a single Baseline; Project Online and desktop support up to 11.If skipped: Losing the source Baseline breaks every Earned Value report and SPI/CPI calculation post-cutover.
  • Export time-tracking history (timephased Work, Actual Work and Remaining Work) per assignment. Project tracks time at three levels per assignment: planned Work, Actual Work logged so far and Remaining Work. Capture all three; the AssignmentTimephasedDataSet holds the per-day breakdown.If skipped: Aggregated time without timephased detail loses the ability to reconstruct per-day burn-down and trend reports.
  • Export Conversations / task comments where the source captures them (Project for the Web Conversations, Project Online task notes, Project Server PWA discussions). Comments do not import via the standard wizards; capture them as a separate file with task_uid, author_email, created_at and body for the Phase 3 preservation decision.If skipped: Discarding source comments because they "do not import natively" loses years of decision context.
  • Export the project calendar, resource calendars and any task-level calendars per project. Calendars drive every date calculation. Capture working days, working hours, exceptions and the base calendar each one inherits from.
  • Export the custom field definitions per project, including lookup tables, formulas and rollup settings. Project custom fields can carry a formula, a lookup table, a graphical indicator rule and a rollup type. Capture each definition; rebuild on the destination per Phase 1.
  • Export attachments and linked SharePoint documents per task with filename, size, owner, content-type and parent task_uid. Project Online stores attachments on the PWA SharePoint site; Project for the Web links to SharePoint and OneDrive. Pull binaries to a staging location and capture an MD5/SHA-256 per file.If skipped: Re-fetching missing attachments after the source goes read-only is harder than re-uploading from a fresh pull.
  • Export the source workflow / status definitions and custom Status field values. These become the destination's Status lookup table. Capture order and the colour palette where reusing it matters.
  • Export Roadmap definitions if the source uses Project Online or Project for the Web Roadmaps. Roadmaps cross-reference rows from multiple projects. Capture the row → project mapping so the destination Roadmap can be rebuilt.
  • Capture the exact timestamp of every export. This timestamp defines the delta the cutover-day export must catch up. Write it into the file metadata, not just the filename.If skipped: Without a known export timestamp, the delta export at cutover misses any record edited inside an ambiguous window.
3. Transform & Map29 tasks
  • Build a master mapping spreadsheet: one row per source field with destination column, type, transform and required-on-import flag. Include nullability, default value and whether the column is part of any formula or rollup.If skipped: Without a single mapping artefact, transformation rules drift between engineers and the same source field maps two different ways.
  • Resolve every source field with no destination equivalent: drop, concatenate into the Notes field, or create a new custom field. Document the decision in the mapping spreadsheet. Concatenated fields keep history without consuming a custom-field slot.
  • Decide the upsert key per object and document it. Typical: source task UID stored in a Text custom field (e.g. Text30) on the destination. The Project Power Apps bulk operations (CreateMultiple, UpdateMultiple, UpsertMultiple) match on this key for idempotent re-runs.If skipped: Without a stable upsert key, partial re-imports duplicate every previously loaded task.
  • Resolve custom-field type immutability against the destination plan. Project custom field types cannot be changed after creation. Confirm the type per field is correct in the mapping spreadsheet before any field is provisioned on the destination.If skipped: A custom field provisioned as Text that should have been Number must be deleted and recreated, losing every value loaded so far.
  • Resolve Status lookup mismatches against the destination's lookup table. Map ("In Progress", "In-Progress", "Started") to one canonical value; document the consolidation per project.
  • Decide the resource-assignment strategy: best-match by email or assign to a single "migration" service resource. Project for the Web binds assignments to Microsoft Entra users; assignments referencing emails with no matching Entra user fail to create.If skipped: Tasks whose owner emails do not resolve to any provisioned user fail to land assignments and show as unassigned post-cutover.
  • Decide the historical-timestamp strategy. Dataverse system fields (createdon, modifiedon) cannot be overwritten on standard inserts. Either accept import-time created_on and store the original in a custom Date field, or use a backdated-write integration where supported.If skipped: If "original created date" reports drive SLA calculations, losing source timestamps misrepresents historical performance.
  • Convert all date and datetime fields to ISO-8601 with explicit timezone. Project's Date custom fields store local dates and render against the project calendar; mismatched timezones surface as day-shift bugs on Start and Finish.If skipped: Datetime values without timezone shift up to 24 hours depending on the importer's interpretation.
  • Convert Duration values to Project's expected format (e.g. "5d", "40h", "2w"). Duration is stored in minutes internally but accepted in shorthand on import. Confirm whether the import treats a bare number as days or minutes per edition.If skipped: An ambiguous duration of "5" loaded as minutes instead of days collapses a 5-day task to 5 minutes.
  • Normalize currency and cost values to the destination's stored decimal precision and currency code. Rate and Cost fields accept plain numerics; strip currency symbols and thousands separators before write. Confirm the destination currency on the project header.
  • Truncate or split text fields that exceed destination character limits. Project task Name accepts up to 255 characters; Notes accepts longer content. Re-route any over-length text to Notes and keep Name within the cap.If skipped: Truncation without warning silently loses the back half of long task names.
  • Re-encode any non-UTF-8 text content as UTF-8 with BOM. Recent Project desktop updates introduced CSV parsing strictness; UTF-8 with BOM is the most reliable shape across editions.If skipped: Mixed-encoding CSV files surface as garbled cells in the Import Wizard with no row-level error.
  • Escape commas, newlines and quote characters in CSV cells per RFC 4180. Newlines inside task names or Notes split rows in the Import Wizard; quote-wrap and double-escape internal quotes.If skipped: An unescaped newline in a single cell breaks every subsequent row's column alignment.
  • Normalize boolean fields to Project Flag values (Yes/No) per destination column. Source booleans (Y/N, 1/0, true/false) all need to map to Yes/No on destination Flag fields.
  • Implement the chosen resource-assignment strategy across the transformed files. Either resolve every source resource email to a Microsoft Entra user_id, or hard-write the migration service resource_id everywhere unmapped.
  • Stamp original source UIDs into a dedicated Text custom field on every task. Names like source_task_uid in Text30 make later cross-system reporting and audit-log tracing possible.If skipped: Without a back-reference, debugging "why did this task end up here" requires a manual hunt through the source MPP file.
  • Stamp original created_on / modified_on into dedicated Date custom fields alongside the new system timestamps. These power the audit-trail validation in Phase 6.
  • Decide the attachment strategy: SharePoint link, OneDrive link or Dataverse file column. Project for the Web's native pattern is SharePoint document links on each task. Re-uploading binaries into Dataverse consumes file storage; linking preserves SharePoint as the source of truth.If skipped: Re-uploading every binary into Dataverse can exhaust the tenant file storage cap and silently fail later uploads.
  • Map the source project hierarchy onto the Project → Summary Task → Task → Sub-task structure, keeping Resources as a separate dimension. Project's hierarchy is enforced by Outline_Level: a Summary Task is any task with a deeper-Outline_Level task below it. Resources are not part of the hierarchy; they bind to tasks via Assignments.If skipped: Flattening a 5-level source nesting without preserving Outline_Level produces a single-level task list with no rollups.
  • Translate source task dependencies into Predecessor relationships with the correct type (FS / SS / FF / SF) and lead/lag values. Project's Predecessors column accepts the shorthand 12FS+2d (task 12, Finish-to-Start, two-day lag). Build the Predecessors string per task and confirm the Critical Path Method recomputes the expected critical chain.If skipped: Loading dependencies into Auto Schedule mode without correct types or lag re-shifts hundreds of dates the moment the first link is created.
  • Translate source time entries into Work, Actual Work and Remaining Work per assignment, with AssignmentTimephasedDataSet rows for the per-day breakdown where supported. Work is the planned effort; Actual Work is logged so far; Remaining Work is Work − Actual Work. The timephased dataset captures the per-day shape so trend reports survive.If skipped: Loading only Actual Work without Work and Remaining Work corrupts every burn-down and forecast view.
  • Re-create source Conversations on the destination via Project for the Web's task chat (or via Tasks by Planner and To Do where Teams is the surface). The Conversations thread cannot be backfilled by CSV. Options: post each comment as a new message on the destination task after creation, or concatenate into the Notes field on the task.If skipped: Posting every historical comment at high rate burns through throttling limits and stalls.
  • Configure custom workflow status fields and lookup tables on the destination. Project Online supports a custom workflow via the Workflow Manager; Project for the Web uses Dataverse business process flows. Build the workflow shape per project template before any status value is loaded.
  • Re-create source recurring tasks via Insert Recurring Task on the destination, not by loading the expanded rows. Project's Insert Recurring Task generates the future occurrences as the plan moves forward. Loading the expanded rows from source freezes the recurrence and breaks future-date generation.If skipped: Loading the expanded occurrence rows as ordinary tasks loses the recurrence definition; the recurring task stops generating future entries.
  • Capture the source's Baseline snapshot into the destination's Baseline 0 (original plan) so Earned Value Management has a reference point. Project for the Web supports a single Baseline; Project Online and desktop support Baseline through Baseline10. Decide which Baseline slot the source plan lands in before load.If skipped: Without a Baseline captured, every Earned Value report and Schedule Performance Index calculation reads as zero.
  • Plan resource leveling configuration on the destination per project. Resource leveling redistributes work across over-allocated resources. Decide the leveling order (ID, Priority, Standard) and the per-project priority value before the first leveling run after cutover.
  • Choose the import mechanism per object type: Project Import Wizard (UI) or the Power Apps Dataverse bulk operations (CreateMultiple/UpdateMultiple/UpsertMultiple). The Import Wizard suits one-off MPP/XML/CSV files. The Dataverse bulk operations handle Project for the Web at scale.
  • Plan against Dataverse service-protection limits: per-user throttle, per-app throttle and the documented back-off interval. Dataverse meters requests per service principal. Use multiple threads, honour any back-off signal returned, and distribute heavy loads across multiple service principals where supported.If skipped: Unsized batches trigger throttle responses mid-job, leaving partial loads that have to be reconciled by hand.
  • Stage import files in the order: Users → Resources → Projects → Custom Field Definitions → Summary Tasks → Tasks → Sub-tasks → Dependencies → Assignments → Timephased Work → Baselines → Conversations → Attachments. Each later step depends on Dataverse GUIDs produced by earlier steps; the order is fixed.If skipped: Loading sub-tasks before summary tasks leaves orphans; loading dependencies before tasks errors at every pair.
4. Sandbox Test Migration17 tasks
  • Load a representative 1–5% sample of each object into the sandbox Dataverse environment. Sample across project sizes, status values, owners, dates and custom fields. Random sampling is fine; cherry-picked easy rows are not.If skipped: Sampling only the easy rows hides the field-type gotchas until production load.
  • Validate field-by-field on 10–20 random sandbox tasks that values landed in the right column with the right type. Open each task and compare every field to the source row.
  • Specifically test long strings, special characters, embedded newlines and emoji in Name and Notes. These are the cells that surface CSV escaping bugs.
  • Test custom-field imports against the 10-field cap on Project for the Web. Verify each custom field landed in the intended type and that the 10-field ceiling has not been exceeded silently.If skipped: Custom field 11 silently drops on import, losing data that the mapping spreadsheet thought was covered.
  • Test Date, Start, Finish and Deadline imports across timezones to confirm no day-shift. Pick sample rows from at least three timezones, including one east of UTC and one west, and verify the rendered date matches the source.If skipped: Day-shift bugs found in production force a per-row recompute against the source export.
  • Test Predecessor / dependency loads in both Auto Schedule and Manually Scheduled modes. Confirm FS, SS, FF and SF pairs resolve and that lead/lag values render correctly. Verify the Critical Path computed by Project matches the source's critical path.If skipped: Auto-recomputed Critical Path differing from source means downstream forecasts disagree with the historical plan.
  • Test Work, Actual Work and Remaining Work loads against AssignmentTimephasedDataSet on a sample of assignments. Open the Resource Usage view and confirm per-day Work matches the source timephased export.
  • Test Sub-task imports and confirm Outline_Level produces the expected hierarchy. Open the Gantt Chart and verify Summary Tasks roll up the right child tasks and that indentation matches the source.If skipped: A flattened hierarchy requires per-row re-indent under cutover pressure.
  • Test Baseline loads and confirm Baseline 0 reads correctly in the Tracking Gantt. Open the Tracking Gantt and verify the baseline bars render alongside the current schedule.
  • Test Resource and Assignment loads and confirm Microsoft Entra binding resolves. Open a sample task and confirm the assigned resource resolves to a real Entra user, not a placeholder.
  • Test attachment / SharePoint link loads on a sample of tasks. Open the task and confirm each link opens to the expected SharePoint or OneDrive item.
  • Run a full-volume timing test of the largest single project. Time the load of the heaviest project plan to confirm the cutover window has headroom.If skipped: A production project that loads slower than the cutover window leaves the team in a half-migrated state at go-live.
  • Track cumulative Dataverse service-protection consumption across the test runs. Sandbox runs draw against the same per-app throttle. Capture the burn rate per job size so production sizing is empirical.
  • Have a domain expert from the PMO spot-check 25–50 sandbox tasks end to end. Engineers catch type bugs. The team that lives in the data catches semantic bugs.
  • Document every defect, its root cause, and the transform fix. A defect log feeds Phase 6 validation and the post-mortem.
  • Re-run the sandbox load after every transform fix until a full clean run completes. Do not advance to production with known open defects.If skipped: Carrying defects forward to production turns the cutover into the discovery phase.
  • Get written sandbox sign-off from the migration sponsor before scheduling cutover. Sign-off names the sponsor, the date and the explicit success criteria met.
5. Production Cutover11 tasks
  • Confirm the source freeze is in effect and that no new writes have occurred in the last hour. Have an admin lock the source PWA, project files or Dataverse environment to read-only at the documented freeze time.If skipped: A late source write after the delta export creates a task that never lands on Microsoft Project and is invisible to validation.
  • Take the cutover-day delta export across every object type. Capture every record changed since the Phase 2 baseline timestamp. Merge into the staged import files.
  • Re-run the transform pipeline against the merged datasets and produce final destination-shaped import files. Sanity-check the row counts match the merged input.
  • Confirm destination Power Automate flows are paused and notifications are suppressed. Re-verify the Phase 1 pauses are still in effect; flow state can drift between Phase 1 and cutover.If skipped: A re-enabled flow firing on import generates thousands of notifications mid-cutover and floods user inboxes.
  • Execute loads in dependency order: Users → Resources → Projects → Custom Field Definitions → Summary Tasks → Tasks → Sub-tasks → Dependencies → Assignments → Timephased Work → Baselines → Conversations → Attachments. Use CreateMultiple / UpsertMultiple via the Dataverse bulk operations for Project for the Web volumes; use the Project Import Wizard only for one-off MPP/XML files.If skipped: Out-of-order loads error on missing parent IDs and force a partial rollback.
  • Use idempotent UpsertMultiple operations keyed on the source-task-UID custom field for every task load. The Dataverse Upsert action matches on an alternate key; configure the alternate key to the dedicated source-UID Text field before any cutover-day write.If skipped: Non-idempotent inserts on re-run double every previously loaded task.
  • Capture request ID, row count, success count, error count and error log for every CreateMultiple / UpsertMultiple batch. Persist the response to the migration log; correlate retries to the original request via the Retry-After header guidance from Dataverse service protection.
  • Cross-check destination row counts against source row counts at the end of every load step. If counts diverge, stop, diagnose and re-run the step before advancing.If skipped: Continuing past a count mismatch propagates the deficit through every downstream step.
  • If a load step fails partway, halt the pipeline, diagnose, fix the transform and re-run the failed step idempotently. Do not push through with partial data and plan to clean up later.
  • Re-enable destination Power Automate flows once all loads complete and Phase 6 validation has started. Re-enable in waves: first the read-only flows (notifications), then the side-effect flows (status changes, task moves), then the integrations to downstream systems.
  • Re-enable destination notifications, Teams pings and email preferences. Reverse the Phase 1 silencing so the platform behaves normally for end users.
6. Validate22 tasks
  • Compare total task count per project: source vs. destination. Investigate any non-zero delta against the migration log; expect the delta to resolve to known excluded rows or known errors.If skipped: An unexplained count delta means tasks are missing or duplicated and the team does not know which.
  • Compare open task count per project: source vs. destination. An in-progress task that lands at 100% complete (or vice versa) skews every dashboard the moment users log in.
  • Compare sub-task counts per Summary Task across the largest 20 parents. Outline-level orphan rates surface here.
  • Compare dependency-pair counts per project across the projects that use the Critical Path Method. Dependency rows often drop quietly during transform; the Critical Path shifts as a result.
  • Cross-check 25–50 randomly selected tasks field-by-field between source and destination. Cover every column type at least once across the sample. Document any divergence and decide whether to fix or accept.If skipped: Skipping random sampling means systematic bugs in rare columns ship to production users.
  • Verify every custom field has at least one populated value where expected. An entirely empty destination field usually means a mapping bug.
  • Verify Sub-task to Summary Task relationships on a sample of 25 Summary Tasks. Open each Summary Task in the Gantt Chart and confirm the indented children match source.
  • Verify Predecessor / Successor links resolve and the dependency type and lead/lag render correctly. Sample one link per dependency type; confirm both directions resolve and the Critical Path computed matches source.If skipped: Broken dependencies surface as wrong dates and a corrupted Critical Path long after cutover.
  • Verify Resource assignments resolve to active Microsoft Entra users. Open a sample task and confirm the assigned resource has a real mailbox and an active license.
  • Verify timephased Work data on a sample of assignments with the heaviest history. Open Resource Usage view and compare per-day Work, Actual Work and Remaining Work with the source export.
  • Verify attachment / SharePoint links open and the file content matches the source binary. Spot-check 20 random attachments; verify checksums match the Phase 2 capture for at least 5.If skipped: Truncated or replaced binaries are only discoverable by opening the file.
  • Verify Baseline data renders on the Tracking Gantt and reads back via the Project for the Web Power BI dataset. Earned Value Management calculations require a populated Baseline; verify Schedule Variance and Cost Variance compute against the loaded Baseline.
  • Verify the original created_on / modified_on custom fields are populated on every task. Confirm the original timestamp survived into the dedicated custom Date fields per Phase 3.If skipped: Tasks missing the back-reference timestamp lose their audit context permanently.
  • Confirm the Dataverse environment is in the contracted hosting region. Power Platform admin → environment details; for EU customers, verify the region is an EU region and that no replica exists outside the EU Data Boundary.If skipped: A US-region environment holding EU personal data breaches GDPR Article 44 from cutover onward.
  • Verify the signed BAA is in force if the tenant holds PHI. Microsoft 365 HIPAA BAA must be active and the agreement countersigned before PHI is loaded into Project for the Web.
  • Pull the Dataverse audit log and confirm the cutover writes are recorded against the migration service principal. Filter on the application user; cross-check writes against the migration log.
  • Document the data-retention policy on the destination environment. Capture: who can delete, how long deleted Dataverse rows remain in the recycle bin, and the encryption-at-rest position.
  • Have 3–5 project managers validate their day-to-day workflows. Scripts: open a project, add a task, link a predecessor, assign a resource, log Actual Work, take a Baseline, open the Roadmap.If skipped: Skipping UAT means real workflow defects ship to every user simultaneously on day 1.
  • Have a project manager re-create one Power BI dashboard end-to-end on destination and compare against the source. Power BI reports rebuild manually against the new Dataverse source; a clean dry run before opening the platform avoids day-1 reporting gaps.
  • Re-test one full recurring-task definition end-to-end via Insert Recurring Task. Confirm the recurrence generates the expected future tasks on the destination cadence.
  • Capture and triage every UAT defect; classify each as blocker / non-blocker. Blockers gate the Phase 6 sign-off. Non-blockers carry into Phase 7 cleanup.
  • Capture written sign-off from the migration sponsor against the Phase 0 success criteria. Sign-off references the success criteria document by name and explicitly states each criterion is met.If skipped: Without written sign-off, scope debates re-open weeks later under the heading "the migration was never finished".
7. Post-Migration Cleanup12 tasks
  • Communicate go-live to every end user with login instructions, training links and the support intake channel. Pin the announcement in Microsoft Teams and the company knowledge base; do not rely on email alone.
  • Run live training sessions for end users segmented by role. One session for project managers, one for team members, one for resource managers and one for PMO admins. Record each session.
  • Set the source system to read-only and announce the read-only date. Read-only protects the source as a forensic snapshot during the 30/60/90-day fallback window.If skipped: An editable source post-cutover invites users to update both systems and split the source-of-truth.
  • Rebuild reports and dashboards on the destination using Power BI against the Project for the Web Dataverse dataset. Use the Phase 2 dashboard-definition captures as the rebuild spec. Tag every visual with the source name for traceability.
  • Rebuild Power Automate flows using the Phase 2 documentation as the spec. Build in waves: notification flows first, then status-change flows, then cross-system flows. Test each flow in isolation before the next.If skipped: Rebuilding every flow at once and then enabling them in bulk surfaces interaction bugs as a single tangled outage.
  • Rebuild recurring tasks on every project via Insert Recurring Task. Verify the next-fire date is correct; otherwise the first occurrence post-cutover may not match the source cadence.
  • Re-establish integrations to other systems: calendar, email, SharePoint document libraries, Dynamics 365, Power BI. Each integration is its own configuration block; do not bundle them into a single "reconnect everything" ticket.
  • Configure ongoing user provisioning via Microsoft Entra group-based licensing. Without group-based licensing, leavers retain Project Plan seats until manually removed.If skipped: Leavers retaining access exposes the platform to insider-risk breaches between offboarding and manual removal.
  • Schedule a 30-day retrospective with the migration team and an executive sponsor. Capture what went well, what did not, and what would change for the next migration.
  • Decide and document the source system's decommission date. Common pattern: 90 days after cutover, after the final retention window passes. Communicate to every user.
  • Archive every source export, MPP/XML file and migration log to long-term storage. Encrypted cold storage in Azure Blob, S3 or equivalent. Tag with the cutover date and the retention period.If skipped: Discarded source exports remove the only forensic record if a post-cutover dispute arises a year later.
  • Close the migration project formally: final status report, lessons-learned doc, project closure email. A formal close prevents the project re-opening every time someone finds an edge case post-cutover.

Questions, answered

Migrating to Microsoft Project: questions

How long does migration to Microsoft Project take?

A small consolidation of under 25 MPP files into a single tenant runs one to two business days end-to-end. A mid-market Project Online to Project for the Web modernisation with custom fields, baselines and timesheets runs four to eight weeks of elapsed time, including pilot, dry runs in a sandbox, validation and training.

Can I migrate from Asana to Microsoft Project?

Yes — Asana is one of the most common sources for Project for the Web. Tasks, sections and dependencies map cleanly via FluentPro Project Migrator or an Excel export with a conversion template. Watch for Asana's 60-fields-per-task ceiling vs. Project for the Web's 10-custom-field cap; many fields need to consolidate.

Can I migrate from Smartsheet or Monday to Microsoft Project?

Yes — Smartsheet and Monday Work Management both export to formats Project can ingest (Excel, CSV, MPP for Smartsheet). FluentPro Project Migrator covers Smartsheet to Project for the Web with object-mapping and user-mapping. Rebuild custom workflow statuses as renamed Text fields with lookup tables on the destination, not as native states.

Does Microsoft Project preserve original timestamps on import?

Partially. On Project Desktop the Import Wizard accepts explicit Start and Finish dates for every task. On Dataverse-backed Project for the Web, `createdon` and `modifiedon` are platform-managed by default; Dataverse exposes `overriddencreatedon` for privileged callers, but modified timestamps always reflect the import job. Use Legacy Created Date custom fields.

Can I migrate baselines into Microsoft Project?

Yes, but baselines do not auto-load with the schedule. Project supports 11 baselines (Baseline plus Baseline1-10) and you map source baseline data to Baseline Start, Baseline Finish, Baseline Duration, Baseline Work and Baseline Cost columns explicitly during import. Default import maps omit these fields — add them or your baselines vanish.

What happens to task dependencies during a Microsoft Project migration?

Dependencies on import require the predecessor task to already exist in the project, and Project's notation is strict (`5FS+2d`, `5SS`, `5FF-1d`). Free-form text like 'Task 5 + 2 days' is rejected. Sort the source so predecessors load first, or run a two-pass import: tasks first, Predecessors column in the second pass.

Is there an undo or rollback for Microsoft Project imports?

Project Desktop's undo stack does not survive a file close — keep the original MPP as your rollback artefact. Dataverse-backed Project for the Web supports record restore from the recycle bin via the Power Platform admin centre for roughly 30 days. Stamp imported tasks with an Import Batch ID custom field for bulk-delete recovery.

Sources

  1. Microsoft Project — Wikipedia
  2. Migrating work items — Microsoft Q&A
  3. Get Ready for Microsoft 365 Ticking Timebomb in 2026 — r/sysadmin
  4. Microsoft Project Server — Wikipedia
  5. Upsert Multiple records in Microsoft Dataverse — Microsoft Learn
  6. Service protection — Finance & Operations | Dynamics 365 | Microsoft Learn
  7. Project programming reference — Microsoft Learn
  8. Project programming basic operations — Microsoft Learn
  9. Microsoft Project Online programming — Microsoft Community Hub
  10. Configure table relationship cascading behavior (Microsoft Dataverse) — Power Apps
  11. Project Online software boundaries and limits — ProjectOnline | Microsoft Learn
  12. Project object model — Microsoft Learn
  13. Project for the Web — 10 custom fields hard limit (Microsoft Tech Community)
  14. Create a custom field in Project — Microsoft Support
  15. Microsoft Project 2016 — Change Field Drop Down List (Stack Overflow)
  16. MS Project Custom Fields Not Calculating Correctly — Microsoft Q&A
  17. File formats supported by Project desktop — Microsoft Support
  18. Export or import data to another file format — Microsoft Support
  19. How to import Actual Work to MS Project 2013 from CSV — pm.stackexchange
  20. Importing a Task Outline Structure into Project — Microsoft Learn
  21. MS Project cannot open CSV in UTF-8 or ANSI encoding — Microsoft Q&A
  22. Dynamics 365 environment strategy guidance — Microsoft Learn
  23. Import Excel data into Project — Microsoft Support
  24. Notes fields — Microsoft Support
  25. Migrate attachments when moving Production database between D365 F&O LCS projects — Microsoft Q&A
  26. File formats supported by Project desktop (alternate doc page) — Microsoft Support
  27. Import a Microsoft Project file with the Import module — ServiceNow
  28. Restore deleted Microsoft Dataverse table records — Power Platform admin
  29. Keeping the original Date Modified/Modified By in MS Teams/SharePoint — Microsoft Q&A
  30. Import Actual Work numbers in MS Project (bulk import) — Microsoft Q&A
  31. What is the EU Data Boundary? — Microsoft Privacy
  32. Microsoft completes landmark EU Data Boundary — Microsoft On the Issues
  33. Comment on tasks in Microsoft Planner — Microsoft Support
  34. Timesheet entries move task's start date — Microsoft Tech Community
  35. Link tasks in a project — Microsoft Support
  36. MS Project Alternative: Top 15 Tools Compared For 2026 — Monday
  37. Project Migrator — Microsoft Marketplace (FluentPro Software)

Get a quote

Moving to Microsoft Project?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Microsoft Project setup with you, then send a quote.

Get a quote