Project Management migration

Migrate from Redmine to monday Work Management

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 logo

Redmine

Source

monday Work Management

Destination

monday Work Management logo

Compatibility

64%

9 of 14

objects map 1:1 between Redmine and monday Work Management.

Complexity

CModerate

Timeline

2-4 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

Field-level fidelity

Every standard and custom field arrives verified.

Schema-aware mapping

AI proposes the map; you confirm before any record moves.

Relationships preserved

Parent–child, lookups, and ownership stay linked.

Full activity history

Calls, emails, meetings — with original timestamps.

Attachments & notes

Documents, uploads, and inline notes move with the record.

Why teams make this switch

Two sides of the same decision

Leaving

Redmine logo

Redmine

What's pushing teams away

  • Installation and initial configuration are consistently described as difficult, with a steep learning curve for server administrators new to Ruby on Rails.
  • The user interface is widely criticized as dated and unintuitive, with cluttered project screens and confusing role-based permission setup.
  • Email notifications lag and feel outdated compared to modern real-time collaboration tools, frustrating teams expecting Slack-style updates.
  • Performance degrades with large numbers of projects and issues, and no native mobile app forces reliance on a mobile-unfriendly web interface.
  • Hidden costs accumulate through required hosting fees, paid plugins for enterprise features, and ongoing IT maintenance overhead.

Choosing

monday Work Management logo

monday Work Management

What's pulling them in

  • Lowest onboarding friction of any mid-market PM tool — drag-and-drop boards and colorful UI mean non-technical team members contribute from day one without training.
  • Highly customizable board structure lets teams model their actual workflow rather than forcing a predefined template onto their process.
  • Generous free forever plan with two seats lets small teams or solo users validate the platform before committing budget or migrating data from elsewhere.
  • Integrations with Slack, Zoom, Google Drive, and CRM tools keep monday.com as a coordination hub rather than requiring teams to switch context constantly.
  • Multiple view modes — Kanban, Calendar, Gantt, Map, Chart — give different team members the visualization they prefer without switching tools.

Object mapping

How Redmine objects map to monday Work Management

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

maps to

monday Work Management

Workspace + Board

1:1
Fully supported

Each 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

maps to

monday Work Management

Item

1:1
Fully supported

Redmine 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

maps to

monday Work Management

Board or Group

lossy
Fully supported

Redmine 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

maps to

monday Work Management

Group or Labels

lossy
Fully supported

Redmine 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

maps to

monday Work Management

Status column or Board

lossy
Fully supported

Redmine 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

maps to

monday Work Management

Item with Time Tracking column

1:many
Fully supported

Redmine 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

maps to

monday Work Management

User

1:1
Fully supported

Redmine 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)

maps to

monday Work Management

Column

1:1
Fully supported

Redmine 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)

maps to

monday Work Management

Column (Time Entry item)

1:1
Fully supported

Redmine 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

maps to

monday Work Management

File column on Item

lossy
Fully supported

Redmine 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

maps to

monday Work Management

Doc or Board Update

1:1
Fully supported

Redmine 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

maps to

monday Work Management

Item with File column

1:1
Fully supported

Redmine 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

maps to

monday Work Management

Team

1:1
Fully supported

Redmine 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

maps to

monday Work Management

Board Update

1:1
Mapping required

Redmine 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.

Gotchas + challenges

What specifically takes care here

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 logo

Redmine gotchas

High

No built-in CSV import function for Issues

High

Uploaded files stored on filesystem, not in the database

Medium

CSV exports exclude issue history and journals

Medium

Custom field definitions require a separate API call

Medium

REST API disabled by default on most installations

monday Work Management logo

monday Work Management gotchas

High

Subitems have no bulk export endpoint

High

API complexity budget constrains query depth

Medium

Daily call limits vary sharply across plan tiers

Medium

Automation and integration rules do not export via API

Low

Saved views are not exposed via API

Pair-specific challenges

  • Redmine attachments live on the filesystem, not in the database

    Redmine stores uploaded files on disk under the /files directory (or a configured storage path), not as BLOBs in the database. A database-only migration that ignores the filesystem will lose all uploaded files. We explicitly 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 to relink them. The original filename, content type, and uploader metadata are preserved. This step adds time for migrations with large attachment directories (over 200 files) and must be completed before the item migration phase closes.

  • Issue history (journals) absent from Redmine CSV export

    Redmine's built-in CSV export for Issues captures only the current state of each record. Every status change, comment, and time-log entry recorded against the Issue is absent from the CSV. We flag this gap during scoping. If journal history preservation is required, we pull the journals table directly from the Redmine database and append each entry as a monday.com Item update with a timestamp. If journal history is not required, we note the gap in the migration report and move forward with current-state migration only.

  • monday.com flat board model does not map cleanly to Redmine project hierarchy

    Redmine supports nested subprojects, multiple trackers, Versions, andEnumerations as relational structures. monday.com's board model is flat: Groups exist within a board but there is no subproject record type. We flag the hierarchy decision during scoping: subprojects with independent teams map to separate Boards within a Workspace; subprojects sharing the same team map to Groups within the parent Board. Role-based access control and automation scoping differ significantly between the two models, and we document the chosen structure in the target architecture deliverable.

  • Redmine automations and workflows do not migrate as code

    Redmine Issue statuses, transitions, and any plugin-based workflows (e.g., Redmine Issue Evm, Redmine Checklists, Redmine Working Hours automations) have no direct monday.com equivalent at the automation level. monday.com's automation builder uses board-specific trigger-and-action recipes that do not import from Redmine. We deliver a written inventory of every active Redmine workflow, tracker transition rule, and plugin-based automation with its current configuration and a recommended monday.com automation builder equivalent. The customer's admin rebuilds these manually post-migration.

  • Redmine Custom Field definitions require a separate API call before mapping

    Custom Fields in Redmine are defined separately from the Issue and Time Entry records that use them. To map custom field values correctly, we first call /custom_fields.json to retrieve all field definitions including name, format, possible_values, and the multiple flag. We build this dictionary before processing any records. If the Redmine REST API is disabled (the default on most installations), we fall back to direct database queries against the custom_fields and custom_fields_projects tables. This step is required before any field-level mapping can begin.

Migration approach

Six steps for a successful Redmine to monday Work Management data migration

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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

Context on both ends of the pair

Redmine logo

Redmine

Source

Strengths

  • Completely free with no licensing or user-count constraints.
  • Self-hosted with full source-code access and no vendor lock-in.
  • Rich built-in feature set: Gantt charts, time tracking, wikis, forums, VCS integration.
  • Large community plugin ecosystem extending functionality.
  • Supports 49 languages, cross-platform, and multiple databases.

Weaknesses

  • No native bulk import UI—data entry relies on CSV exports or direct DB access.
  • REST API is read-only by default and must be explicitly enabled by an administrator.
  • Dated, unintuitive interface with steep initial learning curve.
  • No mobile app; mobile web experience is poor.
  • Performance degrades with large data volumes.
monday Work Management logo

monday Work Management

Destination

Strengths

  • Drag-and-drop board UI with near-zero learning curve for non-technical users entering project data for the first time.
  • 20+ column types and unlimited custom columns let teams model arbitrarily complex data structures without developer help.
  • Multi-view support — Kanban, Gantt, Calendar, Timeline, Chart, Map — satisfies different team members without forcing a single layout.
  • Automations cover common trigger-action patterns for teams without dedicated developers to write custom scripts.
  • Free plan for 2 seats and a 14-day trial on all paid tiers make evaluation risk-free before committing to migration scope.

Weaknesses

  • Per-seat pricing with no enterprise flat-rate option means costs scale linearly with headcount, making it expensive at 50+ seats.
  • Subitems lack bulk API access, making them problematic for CRM-style use cases where contact records live as subitems under a company board.
  • Automations and advanced views are gated behind Pro and Enterprise tiers, creating feature deserts on entry-level plans.
  • Dependency column is visually limited — no critical path, no auto-rescheduling, and cross-board dependencies require manual link management.
  • No native document management; docs, wikis, and knowledge bases require a separate integration or third-party workaround.

Complexity grading

How hard is this migration?

Moderate Project Management migration. 4 of 8 objects need a mapping; the rest are 1:1.

C

Overall complexity

Moderate migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Redmine and monday Work Management.

  • Object compatibility

    C

    4 of 8 objects need a mapping; the rest are 1:1.

  • Field mapping clarity

    C

    Field mapping is derived from defaults — final spec confirmed during the sample migration.

  • Timeline complexity

    B

    8-object category — typical timelines run 2–7 days end-to-end.

  • API constraints

    B

    Redmine: Not publicly documented; varies by host server configuration.

  • Data volume sensitivity

    B

    Redmine doesn't expose a bulk API — REST + parallelization used for high-volume runs.

Estimator

Estimate your Redmine to monday Work Management migration cost

Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.

Step 1

What are you migrating?

Pick a category, then your source and destination platforms.

Category

FAQ

Frequently asked questions about Redmine to monday Work Management data migrations

Answers to the questions buyers ask most during Redmine to monday Work Management migration scoping. Not seeing yours? Book a call.

Can't find your answer?

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 consultation

Most migrations land between two and four weeks for accounts under 5,000 issues with a straightforward project structure and no preserved journal history. Migrations with large attachment directories (over 500 files), multiple subprojects, time entry preservation, journal history extraction from the journals table, or Redmine installations without API access enabled move to six to ten weeks because of filesystem copy operations, bulk file re-uploads, and schema redesign for the flat board model. monday.com's migration guide similarly notes two to eight weeks depending on data volume for professional service-led migrations.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Redmine.
Land in monday Work Management, intact.

Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.

Accuracy guarantee Rollback included Quote in 1 business day