Microsoft Project to Jira migration
Moving from Microsoft Project to Jira translates your project plans into an issue-tracking environment that supports Scrum, Kanban, and hybrid workflows natively. FlitStack AI maps every task hierarchy, WBS code, resource assignment, and dependency chain into Jira's project and issue-link model — preserving original start dates, finish dates, percent-complete values, and baseline data where Jira's field model allows.
FlitStack AI migrates jira projects, epics, story or task issues, subtasks and epic-story hierarchy or labels from Microsoft Project to Jira, with their history and the associations between records. Every field is mapped and validated, a sample run is checked with you before the full migration, and the whole move can be rolled back in one click. Typical timeline: 24–72 hours for under 5,000 tasks and basic WBS hierarchy.

What moves from Microsoft Project to Jira?
Microsoft Project structures work as a WBS-first task hierarchy with finish-start dependencies and resource allocations on a project-level calendar.
Read the full summary
Jira Software structures work as an Epic-Story-Task-Subtask issue hierarchy with issue links for dependencies and sprint-based execution. The migration maps Microsoft Project tasks to Jira issues, WBS codes to Epic parents, resource assignments to Jira assignees via email matching, and Microsoft Project dependencies to Jira issue links (blocks / is blocked by). Milestones migrate as Jira Versions (Releases) or as dedicated issue types depending on your configuration. Custom fields map field-by-field with type-aware conversion. Microsoft Project resource pools translate to Jira user accounts — unmatched resources are flagged before migration. FlitStack AI does not migrate Project calendars, resource level curves, or cost rate tables — those are destination-side configuration. Views, filters, and reporting templates must be rebuilt in Jira's dashboard model. FlitStack AI prepares a pre‑migration inventory that records task counts, resource pool sizes, custom field definitions, and dependency complexity to confirm scope before the run. The migration uses Jira's Bulk API for high‑volume issue creation and injects dependency links after issue seeding to resolve foreign keys correctly. For WBS chains that exceed Jira's three‑level Epic‑Story‑Subtask structure, additional levels are stored in a WBS_Code__c custom field and optionally applied as Jira Labels for filtering. Baseline dates are preserved in Baseline_Start__c and Baseline_Finish__c fields; visual comparison charts require a Jira add‑on such as Structure or BigGantt.
Project → Jira Project
Each Microsoft Project file (.mpp) or PWA project maps to one Jira project.
How it maps
Project-level metadata — name, description, start date, finish date — translates to Jira project fields. Multiple .mpp files require multiple Jira projects or a shared Jira project with components.
Task (summary task) → Epic
Summary tasks in MS Project with child subtasks map to Jira Epics.
How it maps
The Epic summary, description, and start/due dates pull from the summary task's name, notes, and scheduling dates. Epics serve as the WBS level-1 container in Jira's hierarchy. The mapping also inherits any custom field values defined on the summary task into the Epic's custom fields, ensuring continuity of metadata across the hierarchy.
Task (standard) → Story or Task issue
Standard MS Project tasks map to Jira Stories (for deliverable-oriented work) or Tasks (for activity-oriented work).
How it maps
The issue type is configurable — we use Story as the default for tasks with an assignable deliverable and Task for general work items.
Task (subtask) → Subtask
MS Project subtasks under a parent task map to Jira Subtasks linked to their parent Story or Task.
How it maps
Subtask inherits the parent's Epic link when the parent is part of an Epic-Story hierarchy. If the subtask carries resource assignments or custom fields, those values are copied to the Jira Subtask as well, preserving allocation and metadata continuity.
WBS Code → Epic-Story hierarchy or Label
MS Project WBS codes encode hierarchical task numbering (e.g., 1.2.3).
How it maps
We map WBS levels to Jira's Epic-Story-Subtask nesting where possible. Deep WBS structures beyond three levels are preserved as a custom WBS_Code__c field and optionally as Jira Labels for filtering.
Milestone → Version (Release)
MS Project milestones (zero-duration tasks) map to Jira Versions (Releases) if the milestone represents a delivery checkpoint, or to a dedicated milestone issue type if your Jira project uses one.
How it maps
Target dates map to the Version release date field. If mapped as a Version, the milestone's finish date populates the release date, preserving any linked description.
- ProjectJira Project1:1
- TaskEpictransformed
- TaskStory or Task issue1:1
- TaskSubtask1:1
- WBS CodeEpic-Story hierarchy or Labeltransformed
- MilestoneVersiontransformed
+ 7 more in the mapping below
How Microsoft Project and Jira differ
The differences that decide how each record is mapped. These are what a CSV export and a native importer don't resolve for you.
| Dimension | Microsoft Project | Jira |
|---|---|---|
| Primary structure | WBS-first task hierarchy with summary tasks and subtasks under a single project | Epic-Story-Task-Subtask issue hierarchy with components and versions within Jira projects |
| Dependencies | Finish-to-Start, Start-to-Start, Finish-to-Finish, Start-to-Finish with lead/lag time | Issue links (blocks / is blocked by / relates to) with no native lead/lag support |
| Resources | Named resource pools with capacity, cost rates, and assignment units per task | Jira user accounts matched by email; capacity modeled via Sprint velocity or third-party apps |
| Milestones | Zero-duration tasks marked as milestones with specific finish dates | Jira Versions (Releases) or a dedicated milestone issue type configurable per project |
| Scheduling | Auto-calculated critical path, leveling, and baseline tracking per project plan | Start date / due date fields on issues; critical path requires Structure or BigGantt add-ons |
| Progress tracking | Percent complete per task, resource level curves, earned value metrics | % Done on issues, story points, or time tracking — no native earned value analysis |
| Custom fields | Enterprise custom fields with text, number, cost, date, flag, and formula types | Jira custom fields with configurable context per project; type conversion applied during mapping |
Microsoft Project to Jira field mapping
The 26 most-used fields of 26 mapped for this pair. Custom fields are added from your own schema during scoping. Download the full mapping (CSV) ↓ or open it in the field mapping template.
-
NameTaskSummaryIssue -
NotesTaskDescriptionIssue -
StartTaskStart DateIssue -
FinishTaskDue DateIssue -
DurationTaskOriginal Estimate (Work)Issue
| Microsoft Project field | Jira field | Mapping | Note |
|---|---|---|---|
Task.Name | Issue.Summary | direct | |
Task.Notes | Issue.Description | direct | |
Task.Start | Issue.Start Date | direct | |
Task.Finish | Issue.Due Date | direct | |
Task.Duration | Issue.Original Estimate (Work) | transformed | MS Project duration in days converted to Jira work hours (duration_days * 8). Jira stores work as a time-tracking string. |
Task.% Complete | Issue.% Done | direct | |
Task.WBS | Issue.Parent Epic Link or Label | transformed | WBS level 1 maps to Epic Link. Levels 2+ stored in WBS_Code__c custom field and optionally as Labels. |
Task.WBS Level | Issue.Issue Type (Epic / Story / Task / Subtask) | transformed | WBS depth maps to Jira issue type hierarchy: WBS 1 = Epic, WBS 2 = Story, WBS 3+ = Task or Subtask. |
Task.Is Milestone | Version.Release Date | transformed | Milestone tasks with target dates create Jira Versions with the finish date as the release date. |
Task.Priority | Issue.Priority | value_mapping | MS Project priority values (1–10 or High/Medium/Low) mapped to Jira Priority values (Highest / High / Medium / Low / Lowest). |
Task.Critical | Issue.Label | custom_field_required | MS Project critical path flag stored as a custom Label 'critical-path' in Jira — Jira has no native critical path field. |
Dependency.PredecessorLink | Issue Link.Type | direct | |
Dependency.DependencyType | Issue Link.Link Type + Dependency_Type__c | transformed | Finish-to-Start maps to 'blocks'. Start-to-Start and Finish-to-Finish map to 'relates to' with custom field note. |
Resource.Name | User.Display Name | transformed | Matched to Jira user by email. Unmatched resources flagged for manual account creation before migration. |
Resource.Email | User.Email | direct | |
Assignment.Units | Issue.Assignee | transformed | MS Project assignment units (e.g., 50%) used to determine if a task is assigned to one or multiple Jira users. |
Assignment.Work | Issue.Original Estimate | direct | |
Project.Name | Project.Name | direct | |
Project.Start Date | Project.Start Date | direct | |
Project.Finish Date | Project.End Date | direct | |
Baseline.Baseline Start | Issue.Baseline_Start__c | custom_field_required | Jira requires custom fields for baseline data — created as datetime fields on the issue object. |
Baseline.Baseline Finish | Issue.Baseline_Finish__c | custom_field_required | Jira requires custom fields for baseline data — created as datetime fields on the issue object. |
Baseline.Baseline Name | Issue.Baseline_Name__c | custom_field_required | Stores the baseline label (e.g., 'Baseline 1', 'Current Plan') for multi-baseline support. |
Task.Created | Issue.Created | direct | |
Task.Modified | Issue.Updated | direct | |
Task.ID (internal) | Issue.Source_System_ID__c | custom_field_required | MS Project task UID stored on Jira issue for traceability and delta-run de-duplication. |
What to watch for in a Microsoft Project to Jira migration
The issues we plan around on this pair: limits and data-model gaps that the official import tools leave to you.
Jira has no native critical path — it requires a third-party app
Microsoft Project calculates critical path automatically based on dependencies and task durations.
How we handle it
Jira Software has no native critical path feature. If your MS Project plans rely on critical path analysis, Structure (by Adaptavist) or BigGantt for Jira are the standard add-ons. We preserve the critical flag as a Jira Label on migrated issues, but the automated critical path visualization must be implemented post-migration with a compatible app. This is a pair-level limitation because it specifically affects MS Project plans that use critical path scheduling as a governance tool.
Lead and lag time on dependencies does not translate natively
Microsoft Project supports lead time (negative lag) and lag time (positive delay) between predecessor and successor tasks.
How we handle it
Jira issue links support a 'weight' field that can store days, but Jira's interface does not display lead/lag visually on the backlog or board. We store the original lead/lag days in a custom field (Dependency_Lag_Days__c) on the issue link record, but the visual representation and automatic schedule recalculation based on lag time must be rebuilt manually in Jira's sprint planning or using a Gantt-chart add-on like Structure or BigGantt.
Resource leveling and capacity planning have no Jira equivalent
Microsoft Project's resource leveling engine automatically adjusts task schedules based on resource over-allocation.
How we handle it
Jira has no native resource leveling or capacity planning — it tracks per-user workload on the board but does not automatically reschedule tasks when a resource is over-allocated. We migrate the resource assignments as Jira assignees and store the original allocation units in a custom field, but capacity balancing must be handled through Jira's sprint velocity model, third-party apps like Tempo for resource planning, or manual workload management.
WBS hierarchies deeper than three levels require custom field fallback
Jira's standard issue hierarchy supports Epic → Story → Subtask (three levels).
How we handle it
MS Project WBS codes can go five, six, or more levels deep. For WBS structures beyond Story level, we map the extra levels into a custom field (WBS_Code__c) and optionally create Jira Epic-High-Level-Task-Low-Level mappings where your Jira admin has configured a custom hierarchy scheme. The mapping plan surfaces exactly which WBS levels are covered by native Jira hierarchy versus custom field before migration runs.
MS Project custom enterprise fields require Jira custom field context setup
Microsoft Project enterprise custom fields (outline codes, cost/resource type fields) have enterprise-level scoping.
How we handle it
Jira custom fields require explicit context assignment per project — a custom field created globally is not automatically visible on issues until a Jira admin configures the field context. We deliver a custom field creation and context assignment plan as part of the migration package, but Jira admin privileges are required to apply it before the data migration stage.
How the migration runs
Export Microsoft Project data via API or MPP file
FlitStack AI extracts project data from Microsoft Project via the Project Online REST API (for PWA instances) or parses the .mpp binary file directly for desktop MS Project.
What this step covers
We pull projects, tasks, resources, assignments, dependencies, baselines, and custom enterprise fields. The export uses scoped read access — no write permissions are requested on your MS Project instance. We generate a pre-migration inventory listing the number of projects, tasks, unique resources, and custom field count to scope the migration accurately.
Map WBS hierarchy to Jira issue type hierarchy and prepare custom fields
We analyze the WBS depth of your MS Project plans and create a mapping table that assigns each WBS level to a Jira issue type (Epic / Story / Task / Subtask).
What this step covers
Deep WBS structures beyond Jira's three-level native hierarchy are flagged for custom field fallback. We also generate the Jira custom field definitions (Baseline_Start__c, Baseline_Finish__c, WBS_Code__c, Dependency_Type__c, Source_System_ID__c) with context assignment per Jira project. You or your Jira admin apply the field configuration before migration — we deliver the step-by-step plan.
Match MS Project resources to Jira users by email and resolve dependencies
MS Project resources are matched to Jira user accounts by email address.
What this step covers
Unresolved resources — generic resources without emails, equipment resources, or resources whose Jira accounts haven't been provisioned — are listed in a pre-migration gap report. We also analyze the dependency graph for circular references and map dependency types (FS, SS, FF, SF) to Jira issue link types. Start-to-Start and Finish-to-Finish dependencies that cannot map natively are flagged with a note for manual follow-up after migration.
Run sample migration with field-level diff before full run
A representative slice — typically 100–500 issues spanning multiple Epics, stories, and subtasks with dependencies — migrates first into your target Jira project.
What this step covers
We generate a field-level diff report showing source field values against destination field values for each migrated issue. You verify that WBS-to-Epic mapping, dependency direction, date fields, and baseline custom fields are correct. We refine the mapping plan based on your feedback before committing to the full run.
Execute full migration with delta-pickup window and rollback plan
The full migration runs against Jira using the Bulk API for high-volume issue creation.
What this step covers
A delta-pickup window (24–48 hours) captures any new or modified MS Project tasks during the cutover window. We apply the dependency links after issue creation to ensure foreign keys resolve correctly. An audit log records every operation — issue created, link created, custom field set. If reconciliation fails, one-click rollback reverts Jira to its pre-migration state. We do not modify your MS Project instance during the migration.
- Connect
- Map
- Sample
- Migrate
- Verify
- Contacts48,210 / 48,210 Done
- Companies9,134 / 9,134 Done
- Deals6,377 / 11,920 In progress
- Before sample runRestore point 01Restore
- Before full migrationRestore point 02Restore
- After verificationRestore point 03Current
How long it takes, and what drives the quote
A quote scales with the number of tasks migrated, the number of custom fields requiring type-aware conversion, and the complexity of the dependency graph. Standard single-project migrations with under 5,000 tasks and fewer than 20 custom fields fall in the lower range. Multi-project migrations, WBS hierarchies deeper than four levels, and configurations requiring Jira custom field context setup per project push into the upper range. Resource pool mapping that requires Jira user account provisioning adds planning time before migration runs. Every quote is scoped with you; there is no self-serve pricing.
Get a quote for Microsoft Project to Jira →Why teams move from Microsoft Project to Jira
- Microsoft Project's top-down planning model leaves teams updating the plan manually while work happens elsewhere — creating stale project status and disconnect between the PMO view and execution. Jira's issue-first model keeps the plan and the work in the same system, so status updates reflect actual progress without a separate reconciliation step.
- MS Project is licensed per user and the desktop client requires Windows — remote and cross-platform teams end up sharing MPP files or exporting to PDF. Jira runs in a browser with real-time collaboration, @mentions in comments, and Slack integration, eliminating the file-handoff bottleneck that Planners and consultants frequently cite as a friction point.
- Agile and hybrid teams moving away from waterfall find MS Project's task-mode switching and constraint scheduling cumbersome for sprint planning. Jira's native Scrum and Kanban boards, combined with backlog grooming workflows, better support iterative delivery cycles that modern engineering and product teams expect.
- Organizations standardizing on Atlassian tools for development (Bitbucket, Confluence, Opsgenie) gain single-sign-on, unified admin, and cross-tool reporting by consolidating project management in Jira rather than maintaining a separate Microsoft Project Online PWA instance with its own licensing and admin overhead.
- MS Project Online PWA retirement announced for September 30, 2026 — organizations that delay migration risk losing access to project plans, historical reporting data, and workflow configurations. Migrating to Jira before the deadline consolidates the toolset and avoids emergency last-minute moves.
Questions, answered
Microsoft Project to Jira migration questions
How long does a Microsoft Project to Jira migration take?
Most Microsoft Project to Jira migrations complete in 24–72 hours of clock time for a single project with under 5,000 tasks. Multi-project migrations or plans exceeding 20,000 tasks typically extend to 5–10 business days. The longest planning step is configuring Jira's issue type hierarchy, custom field context assignments, and resolving unmatched resources before the migration run. We include a pre-migration gap report that estimates the full timeline based on your specific plan complexity.
Will my Microsoft Project views, reports, and filters migrate to Jira?
No. FlitStack AI migrates data and schema only — Microsoft Project views (Gantt views, usage views, resource sheets), reports (earned value, cash flow, resource histograms), and custom filters do not migrate to Jira. They must be rebuilt in Jira's dashboard and filter model. Jira has no native earned value analysis; teams that need that reporting typically use Structure or BigGantt add-ons. We can export your MS Project view definitions as a reference document for your Jira admin to use during rebuild.
What happens to MS Project WBS codes and task hierarchy in Jira?
MS Project WBS codes map to Jira's Epic-Story-Subtask issue type hierarchy — WBS level 1 becomes a Jira Epic, level 2 becomes a Story, and deeper levels become Tasks or Subtasks. For WBS structures beyond three levels, we preserve the full WBS path in a custom WBS_Code__c field and optionally as Jira Labels for filtering. Jira's native issue hierarchy supports only Epic → Story → Subtask, so deeply nested WBS plans require the custom field fallback approach.
Can I migrate MS Project milestones to Jira?
Yes. MS Project milestones — zero-duration tasks marked as milestones with a target date — map to Jira Versions (Releases) when they represent delivery checkpoints, or to a dedicated milestone issue type if your Jira project uses one. We store the milestone target date in the Jira Version's release date field or the issue's Due Date field depending on your selected configuration. We do not migrate milestone dependencies or milestone-specific scheduling logic.
How does MS Project resource allocation translate to Jira?
MS Project resources are matched to Jira user accounts by email address. Task assignments with work hours map to Jira issue assignees with the original work estimate stored in the Work field. MS Project assignment units (e.g., 50% for half-time allocation) are preserved as a custom Allocation_Percent__c field. Jira has no native resource leveling or capacity planning — teams needing that functionality use Tempo Timesheets or Capacity Planner add-ons. Unresolved resources are flagged in the pre-migration gap report for manual Jira account provisioning.
Does the migration affect my Microsoft Project account during cutover?
No. FlitStack AI uses scoped read access on Microsoft Project — your team continues working in MS Project throughout the migration. We extract the current state of projects, tasks, resources, and dependencies at migration start. A delta-pickup window (24–48 hours) captures any records created or modified in MS Project during the cutover so Jira reflects the final state at go-live. We do not write to MS Project at any point during the migration.
What happens to MS Project baselines in Jira?
Microsoft Project baselines are stored as custom datetime fields in Jira (Baseline_Start__c, Baseline_Finish__c, Baseline_Duration__c) since Jira has no native baseline concept. Multiple baselines per task are supported via a Baseline_Name__c field that stores the baseline label. Baseline comparison charts — the feature PMs use to track schedule variance — do not migrate. Teams that need baseline tracking in Jira use Structure or BigGantt add-ons to visualize planned versus actual dates post-migration.
Related migrations
Sources: official documentation
- Import data from a CSV file — Atlassian Support
- Link your object schema to a Jira project — Jira Service Management Data Center
- Importing data from CSV — Administering Jira applications Data Center
- Migrating work items — Microsoft Q&A
- Upsert Multiple records in Microsoft Dataverse — Microsoft Learn
- Service protection — Finance & Operations | Dynamics 365 | Microsoft Learn
Get a quote
Moving from Microsoft Project to Jira?
Tell us roughly how many records and objects you have. We scope the mapping and the Jira setup with you, then send a quote.
Get a quote