Project Management migration
Field-level mapping, validation, and rollback between Redmine and Microsoft Project. We move data and schema; workflows are rebuilt natively in Microsoft Project.
Redmine
Source
Microsoft Project
Destination
Compatibility
6 of 10
objects map 1:1 between Redmine and Microsoft Project.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from Redmine to Microsoft Project is a paradigm migration, not a direct record copy. Redmine organizes work around Issues inside Projects with a flexible tracker system; Microsoft Project organizes work around Tasks inside a Project Plan with start/end dates, dependencies, and resource assignments. We extract Redmine data via its REST API (or direct database access for large exports), transform the issue hierarchy into a task dependency graph, map Redmine Users to MS Project Resources, and reconstruct time-tracking data as Task Usage entries. Custom Fields require explicit value mapping since MS Project supports a narrower set of field types than Redmine. Note that Microsoft Project Online retires September 30, 2026; teams migrating from Redmine typically target Project Plan 3 or Project desktop, not Project Online. Workflows, Wiki pages, Forums, and News entries do not migrate; we deliver a written inventory of these objects for the customer's PMO to rebuild or archive in Microsoft SharePoint.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a Redmine object lands in Microsoft Project, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Redmine
Project
Microsoft Project
Project (MPP file or Project for the web)
1:1Each Redmine Project maps to one Microsoft Project plan (MPP file or Project for the web project). Subprojects in Redmine become summary tasks or separate linked subprojects in MS Project depending on the customer's preference. We extract project metadata including name, identifier, description, homepage, and public/private flag. Parent-child project hierarchy is preserved by either creating nested projects (Project for the web) or summary tasks (MPP file).
Redmine
Issue
Microsoft Project
Task
1:1Redmine Issues map directly to MS Project Tasks. We extract subject as Task Name, description as Notes, start_date as Start, due_date as Finish, estimated_hours as Estimated Hours (if using Project custom fields), done_ratio as Percent Complete, and priority as a numeric priority flag. Parent Issues become Summary Tasks with child Issues as subtasks. The Redmine tracker (Bug, Feature, Support) is preserved in a custom Task field since MS Project has no native tracker equivalent. Issue ID is stored in a custom field for cross-reference.
Redmine
Version
Microsoft Project
Milestone or Summary Task
1:1Redmine Versions (milestones) map to MS Project Milestones (zero-duration tasks with a milestone flag) or to summary tasks grouping related issues. We map version name to milestone name, version description to Notes, and version due date to the milestone Finish date. Versions without a due date are mapped as summary tasks. Active versus closed status is preserved in a custom field.
Redmine
Time Entry
Microsoft Project
Task Usage (hours per task)
1:manyMultiple Redmine Time Entries for a single Issue aggregate into one task duration entry in MS Project. We sum hours per Issue per User and assign to the corresponding Task as hours in the Task Usage view. Activity type (development, design, research) is stored as a text field on the assignment. Time entries without a linked Issue are flagged during discovery for manual mapping to a task or exclusion.
Redmine
User
Microsoft Project
Resource
1:1Redmine Users map to MS Project Resources. We extract first name, last name, email, and admin flag. The admin flag maps to a custom Resource field. Redmine does not store hourly cost rates, so resource rates must be provided by the customer or defaults set. Generic Resources (equipment, rooms) can be created for non-user entities if needed. Inactive Redmine users are mapped to inactive Resources.
Redmine
Issue Assignment
Microsoft Project
Task Assignment
1:1Redmine Issue assignee (user_id) maps to MS Project Task assignment on the corresponding Task. We resolve the Redmine user to the MS Project Resource by email match. Multiple assignees on a single Issue are split into multiple Task assignments with an equal or customer-specified split of the task duration. No assignment mapping exists for Issues with no assignee; these tasks are created as unassigned.
Redmine
Issue Relations
Microsoft Project
Task Dependencies
1:1Redmine Issue Relations (blocks, blocked by, follows, precedes, duplicated by) map to MS Project Task Dependencies (Finish-to-Start, Start-to-Start, Finish-to-Finish, Start-to-Finish). Redmine relation types map as follows: 'precedes' becomes Finish-to-Start; 'blocks' and 'blocked by' become Finish-to-Start with direction adjusted; 'relates to' becomes Finish-to-Start. Lag time is preserved where applicable. Relations referencing Issues in different Redmine projects are mapped to cross-project dependencies in MS Project if both projects are included in migration.
Redmine
Custom Field
Microsoft Project
Custom Field or Text Field
lossyRedmine Custom Fields defined per Issue are mapped to MS Project Task Custom Fields where possible. Text, numeric, date, boolean, and list (enumeration) custom field types have direct equivalents. User-type and Version-type custom fields require lookup resolution or are mapped to text fields with the referenced value as a string. Multi-select list fields in Redmine are mapped to text fields with comma-separated values. Custom Field definitions are retrieved via /custom_fields.json before any data extraction begins.
Redmine
Attachment
Microsoft Project
Hyperlink or Document Library
lossyRedmine file attachments (stored on the filesystem under /files) are enumerated during discovery, copied from the Redmine server, and re-uploaded as hyperlinks on the corresponding MS Project Task Notes field or as files in a linked SharePoint document library. The destination approach is agreed upon during scoping. File content is not embedded inside the MPP file due to size constraints.
Redmine
Tracker
Microsoft Project
Custom Task Field
lossyRedmine Trackers (Bug, Feature, Support, and any custom trackers) do not have a native equivalent in MS Project. We create a Task-level custom text field named 'Redmine_Tracker' and populate it with the original tracker name from each Issue. This preserves the categorization for reporting and filtering in Microsoft Project. Custom tracker definitions (tracker-level custom fields) require manual recreation in MS Project if needed.
| Redmine | Microsoft Project | Compatibility | |
|---|---|---|---|
| Project | Project (MPP file or Project for the web)1:1 | Fully supported | |
| Issue | Task1:1 | Fully supported | |
| Version | Milestone or Summary Task1:1 | Fully supported | |
| Time Entry | Task Usage (hours per task)1:many | Fully supported | |
| User | Resource1:1 | Fully supported | |
| Issue Assignment | Task Assignment1:1 | Fully supported | |
| Issue Relations | Task Dependencies1:1 | Fully supported | |
| Custom Field | Custom Field or Text Fieldlossy | Fully supported | |
| Attachment | Hyperlink or Document Librarylossy | Fully supported | |
| Tracker | Custom Task Fieldlossy | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
Redmine gotchas
No built-in CSV import function for Issues
Uploaded files stored on filesystem, not in the database
CSV exports exclude issue history and journals
Custom field definitions require a separate API call
REST API disabled by default on most installations
Microsoft Project gotchas
Project for the web is being retired and merged into Microsoft Planner
Planner-tier portfolio features are incomplete despite Plan 5 labeling
Web app constraint controls are weaker than the Windows desktop client
Project requires a separate license not bundled with standard Microsoft 365
Project Online API is edition-gated and inconsistently documented
Pair-specific challenges
Migration approach
Discovery and target product confirmation
We audit the Redmine instance via API or direct DB access to enumerate Projects, subprojects, Issues, Versions, Time Entries, Users, Custom Fields, Trackers, Issue Relations, and Attachments. We confirm the destination product (Project desktop, Project Plan 3, or Project for the web) during scoping because each has a different import path. We also confirm whether the customer is consolidating multiple Redmine instances into one Microsoft Project plan or keeping a one-to-one project mapping. The discovery output is a written scope document with estimated row counts per object and a data quality assessment.
API and access preparation
We verify that the Redmine REST API is enabled and accessible, or prepare read-only database credentials for direct MySQL or PostgreSQL access if the API is disabled. We confirm that the migration user has access to the attachments directory and that all source data can be reached in a single extraction session. For Project for the web destinations, we provision a Microsoft 365 environment and confirm API permissions for the FlitStack AI migration service. For desktop MPP destinations, we prepare the target workstation with a supported MS Project version.
Schema and mapping design
We design the object mapping: Redmine Projects to MS Project plans, Issues to Tasks with parent-child hierarchy from subprojects and parent Issues, Versions to Milestones, Users to Resources, Time Entries to Task Usage entries, and Issue Relations to Task Dependencies. We create the custom field definitions in MS Project for Tracker, Issue Status, and any Redmine Custom Fields that require preservation. For Project for the web, we deploy fields via the Planner API; for desktop, we configure the custom fields in the MPP template before import.
Data extraction and transformation
We extract all source objects in dependency order: Projects first, then Versions, then Users, then Issues with parent references and custom field values, then Issue Relations, then Time Entries, then Attachments. We transform each record using the mapping design, compute task hierarchy (summary tasks from parent Issues and subprojects), resolve user-to-resource assignments, and build the dependency graph from Issue Relations. All transformation logic is logged to a migration trace file for reconciliation. Any Issue with a missing parent is flagged for manual parent assignment or mapped as a top-level task.
Validation and sandbox import
For Project for the web, we perform a trial import into a non-production environment to validate task hierarchy, dependency rendering, resource assignment, and custom field population. For desktop MS Project, we import into a test MPP file and share it with the customer's PM lead for manual review. We reconcile row counts (Issues in, Tasks out; Time Entries in, Task Usage hours out) and spot-check five to ten records per project against the source. Any mapping corrections are applied to the transform script before the production import.
Production import and file handoff
We run the production import in a single cutover window or a phased cutover by project if the customer has active work in multiple Redmine projects. For desktop MPP files, we deliver the final MPP files organized by project with a readme documenting the mapping, custom field definitions, and any issues encountered during import. For Project for the web, we import via the Planner or Project API and confirm all tasks, dependencies, and resources appear in the target environment. We deliver the attachment archive and journal CSV as supplemental files. We do not rebuild Redmine Wiki pages, Forums, News, or automations in MS Project; these are documented in the handoff package for the customer's PMO to address separately.
Platform deep dives
Redmine
Source
Strengths
Weaknesses
Microsoft Project
Destination
Strengths
Weaknesses
Complexity grading
Standard Project Management migration. 2 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Redmine and Microsoft Project.
Object compatibility
2 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
Redmine: Not publicly documented; varies by host server configuration.
Data volume sensitivity
Redmine doesn't expose a bulk API — REST + parallelization used for high-volume runs.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Redmine to Microsoft Project migration scoping. Not seeing yours? Book a call.
Walk through your Redmine to Microsoft Project migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave Redmine
Other ways to arrive at Microsoft Project
Same-Project Management migrations
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.