Project Management migration
Field-level mapping, validation, and rollback between Redmine and monday Work Management. We move data and schema; workflows are rebuilt natively in monday Work Management.
Redmine
Source
monday Work Management
Destination
Compatibility
9 of 14
objects map 1:1 between Redmine and monday Work Management.
Complexity
CModerate
Timeline
2-4 weeks
Overview
Redmine to monday.com is a schema redesign, not a direct record copy. Redmine organizes work inside Projects with Issues, Versions, and Trackers as relational tables; monday.com uses a flat board-and-item model with groups and subitems for hierarchy. The migration requires extracting Redmine data via its Ruby-on-Rails database or its read-only-by-default REST API, mapping Redmine Projects to monday.com Workspaces and Boards, and handling the fact that Redmine stores file attachments on disk under /files rather than in the database. We copy those files separately, re-upload them via the monday.com API to the corresponding items, and resolve the parent-child relationship by item ID. Issue history (journals) is not present in Redmine's CSV export and must be pulled from the journals table if preservation is required. Custom Fields require a separate /custom_fields.json API call to retrieve definitions before field-level mapping can proceed. Automations, roles, and custom workflows do not migrate; we deliver a written inventory for the customer's admin to rebuild in monday.com's automation builder.
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 monday Work Management, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Redmine
Project
monday Work Management
Workspace + Board
1:1Each Redmine Project maps to a monday.com Board within a Workspace. We use the Project identifier and description to seed the Board name and description. Subprojects create a separate Board within the same Workspace; the migration notes flag that monday.com's flat board model does not preserve parent-child subproject relationships natively, and the customer chooses whether to use board groups, board linking, or a separate Workspace to represent the hierarchy.
Redmine
Issue
monday Work Management
Item
1:1Redmine Issues map directly to monday.com Items on the corresponding Board. The Issue subject becomes the Item name. Standard fields map to monday.com columns: status to Status column with labels matching Redmine issue statuses (New, In Progress, Resolved, Closed), priority to a Labels column or Priority column, assigned_to to a People column, due_date to a Date column, and description to the Item's text body. Redmine's tracker (Bug, Feature, Support) maps to a Status column group or a dedicated board per tracker if the customer opts for tracker separation.
Redmine
Subproject
monday Work Management
Board or Group
lossyRedmine subprojects map to separate Boards within the parent Workspace or to Groups within the parent Board, depending on the customer's chosen structure. The migration notes this is a structural decision made during scoping. Subprojects with fewer than 50 issues map to Groups; subprojects intended as independent workstreams map to separate Boards for cleaner access control and automation scoping.
Redmine
Version
monday Work Management
Group or Labels
lossyRedmine Versions (milestones with name, description, status, and due date) map to Groups within a Board (preserving the due date on the Group header) or to a Labels column, depending on whether the team uses milestones as deadlines or as categorical labels. Version status (open, locked, closed) maps to the Group visibility or a Status label.
Redmine
Tracker
monday Work Management
Status column or Board
lossyRedmine Trackers (Bug, Feature, Support, and any custom trackers) have no direct monday.com equivalent. We map them either to Status column labels within a single Board (all issues, labeled by tracker) or to separate Boards per tracker. The choice is made during scoping based on the customer's workflow. Custom tracker definitions retrieved from /custom_fields.json are used to configure the corresponding column type in monday.com.
Redmine
Time Entry
monday Work Management
Item with Time Tracking column
1:manyRedmine Time Entries linked to a single Issue map to the monday.com native Time Tracking column on the corresponding Item, with hours and comments preserved. When a single Issue has multiple Time Entries from different users or dates, each entry appends a separate time block to the item's Time Tracking column. Hours, activity type, and comments transfer. Note that Redmine's activity enumeration (design, development, research) maps to a Labels column on the item alongside the time data.
Redmine
User
monday Work Management
User
1:1Redmine Users (login, firstname, lastname, email, admin flag) map to monday.com Workspace members. We resolve by email match. Any Redmine User without a matching monday.com account goes to a reconciliation queue for the customer's admin to provision before record import resumes. Redmine's custom user fields map to monday.com People column custom fields if the Pro/Enterprise account supports them.
Redmine
Custom Field (Issue)
monday Work Management
Column
1:1Redmine Custom Fields retrieved from /custom_fields.json map to typed monday.com columns: list-type custom fields map to Dropdown or Labels columns, boolean to Checkbox, date to Date, integer or float to Numbers. The field name from Redmine becomes the column title. Multi-value custom fields (multiple flag set to true) map to Labels columns in monday.com. Custom fields are created per board, not globally, because monday.com Standard tier does not support shared column libraries across boards.
Redmine
Custom Field (Time Entry)
monday Work Management
Column (Time Entry item)
1:1Redmine Time Entry custom fields map to additional columns on the parent Item alongside the native Time Tracking column. We retrieve all time_entry-scoped custom field definitions during discovery and create corresponding columns before the time data import phase.
Redmine
Attachment
monday Work Management
File column on Item
lossyRedmine stores attachment metadata (filename, content_type, filesize, description) in the database and the actual files on disk under the /files directory or a configured storage path. We enumerate the /files directory during discovery, copy its contents to a staging location, and re-upload each file via the monday.com REST API to the corresponding Item using the Redmine issue identifier as the relink key. The original filename, description, and uploader are preserved in the file column metadata.
Redmine
Wiki Page
monday Work Management
Doc or Board Update
1:1Redmine Wiki pages stored with wiki text and attachment references map to monday.com Docs (if the customer licenses monday docs) or to Item updates with the wiki content as formatted text. Wiki text format (Redmine-specific markup) may require transformation depending on the destination format. Attachment links within wiki pages are resolved against the migrated file set.
Redmine
Document
monday Work Management
Item with File column
1:1Redmine Documents are project-level file attachments with titles and descriptions but no direct Issue linkage. We map them to Items on a dedicated Board (or a dedicated Group within the Project board) with the Document title as the Item name, the description as the Item body, and the file attachment migrated via the File column. The absence of an Issue linkage is noted in the migration report.
Redmine
Group
monday Work Management
Team
1:1Redmine Groups used for role assignment map to monday.com Teams. We recreate Group membership by adding the corresponding monday.com users to the Team. monday.com Teams control board access permissions and notification settings. Note that Redmine's role-permission system (Member, Reporter, Non-member, Anonymous) does not map to monday.com's Team-based access model and requires a separate permissions design step.
Redmine
News
monday Work Management
Board Update
1:1Redmine News entries (title, description, author, created_on) map to monday.com Item updates or Board updates depending on whether the team wants them attached to a specific item or as a general board announcement. The News concept has no native equivalent in monday.com, so we flag the mapping decision during scoping.
| Redmine | monday Work Management | Compatibility | |
|---|---|---|---|
| Project | Workspace + Board1:1 | Fully supported | |
| Issue | Item1:1 | Fully supported | |
| Subproject | Board or Grouplossy | Fully supported | |
| Version | Group or Labelslossy | Fully supported | |
| Tracker | Status column or Boardlossy | Fully supported | |
| Time Entry | Item with Time Tracking column1:many | Fully supported | |
| User | User1:1 | Fully supported | |
| Custom Field (Issue) | Column1:1 | Fully supported | |
| Custom Field (Time Entry) | Column (Time Entry item)1:1 | Fully supported | |
| Attachment | File column on Itemlossy | Fully supported | |
| Wiki Page | Doc or Board Update1:1 | Fully supported | |
| Document | Item with File column1:1 | Fully supported | |
| Group | Team1:1 | Fully supported | |
| News | Board Update1:1 | Mapping required |
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
monday Work Management gotchas
Subitems have no bulk export endpoint
API complexity budget constrains query depth
Daily call limits vary sharply across plan tiers
Automation and integration rules do not export via API
Saved views are not exposed via API
Pair-specific challenges
Migration approach
Discovery and Redmine API availability check
We audit the source Redmine installation: API availability (Administration > Settings > API must be enabled), database type (MySQL or PostgreSQL for direct access fallback), Projects and subprojects count, Issues by tracker and status, Time Entry volume, Custom Field definitions via /custom_fields.json, attachment file count and total filesystem size under /files, and active wiki pages and documents. If the API is disabled and the customer cannot enable it, we request read-only database credentials for direct MySQL/PostgreSQL access. The discovery output is a written migration scope with record counts per object, filesystem attachment inventory, and a schema map of all custom field names and types.
Target monday.com schema design
We design the monday.com workspace structure: one Workspace per Redmine installation or per organizational unit, one Board per Redmine Project, and Groups within Boards for Versions or tracker-based separation. We design the column schema per board, matching Redmine fields (status, priority, assignee, due date) to monday.com column types (Status, Labels, People, Date) and creating custom columns for each Redmine Custom Field. The target schema is documented in a written deliverable before any data is created in monday.com.
Workspace and Board provisioning
We create the monday.com Workspace and Board structure using the monday.com REST API: Workspace first, then Boards within it with the correct board type (board, cog, or doc). We pre-create all columns on each Board with correct types before any Items are migrated. We create monday.com Teams and invite all matched users so that User lookups are satisfied at the time of Item creation.
User and Group reconciliation
We extract every distinct Redmine User referenced on Issues, Time Entries, and Documents and match by email against the monday.com Workspace members list. Any Redmine User without a matching monday.com account goes to a reconciliation queue for the customer's admin to provision before record import resumes. Redmine Groups are recreated as monday.com Teams with the corresponding members added.
Sandbox migration and reconciliation
We run a full migration into a monday.com test Workspace using production data volume. The customer's project manager or admin spot-checks 25-50 randomly sampled Items against the Redmine source: subject accuracy, column value mapping (status, priority, assignee, due date), custom field values, and file attachment presence. We reconcile record counts per object and resolve any mapping gaps before production migration begins.
Production migration and filesystem attachment copy
We migrate in dependency order: Boards and column schema first, then Items (Issues mapped to Items with column values, Status mapped to tracker labels, People mapped to assignees, Date mapped to due date), then Time Tracking data appended to Items, then file attachments copied from Redmine's /files directory and uploaded via monday.com API to the corresponding Items. Wiki pages and Documents migrate as Items with text body and file columns. Each phase emits a row-count reconciliation report.
Cutover, validation, and automation rebuild handoff
We freeze Redmine writes during cutover, run a final delta migration of any records modified during the migration window, then enable monday.com as the system of record. We deliver the automation inventory document listing every Redmine workflow and transition rule with recommended monday.com automation equivalents. We support a one-week hypercare window for reconciliation issues. We do not rebuild Redmine workflows, plugins, or custom roles as monday.com automations or permissions; that work is a separate engagement or an internal admin task.
Platform deep dives
Redmine
Source
Strengths
Weaknesses
monday Work Management
Destination
Strengths
Weaknesses
Complexity grading
Moderate Project Management migration. 4 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Moderate migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Redmine and monday Work Management.
Object compatibility
4 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 monday Work Management migration scoping. Not seeing yours? Book a call.
Walk through your Redmine to monday Work Management 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 monday Work Management
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.