Project Management migration

Migrate from Redmine 3.3 to Jira

Field-level mapping, validation, and rollback between Redmine 3.3 and Jira. We move data and schema; workflows are rebuilt natively in Jira.

Redmine 3.3 logo

Redmine 3.3

Source

Jira

Destination

Jira logo

Compatibility

60%

6 of 10

objects map 1:1 between Redmine 3.3 and Jira.

Complexity

BStandard

Timeline

2-4 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from Redmine 3.3 to Jira is a structural migration that requires resolving several schema incompatibilities before any data reaches the destination. Redmine 3.3 stores list-format custom field values as internal numeric IDs rather than display labels, so we query the custom_field definitions table first and build an ID-to-label lookup table before writing to Jira. Redmine has no native bulk-import API, so we sequence CSV exports in ordered chunks and reconstruct parent-child issue relationships using the full Redmine issue ID graph after insertion. Subproject hierarchies in Redmine do not map to Jira project structure — we migrate subprojects as standalone Jira projects within a shared Jira project category so teams can still filter by origin. Gantt chart data and wiki content do not have a direct Jira equivalent; we deliver those as written inventories for admin rebuild in Jira's native roadmap views or Confluence. Jira workflows, Jira Automations, and project boards do not migrate; we deliver a written map of each Redmine workflow state transition for the customer's admin to configure in Jira's workflow designer post-migration.

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 3.3 logo

Redmine 3.3

What's pushing teams away

  • No native Agile experience — Kanban boards and sprint planning require third-party plugins (Backlogs, Agile plugin from RedmineUP, etc.), which is a hard adoption blocker for teams that want Scrum or Kanban out of the box.
  • Stuck on an old release — Redmine 3.3 specifically is years behind the latest 5.x line, missing modern Ruby version support, security patches, and recent UX work; remaining on 3.3 is now a security and supportability risk.
  • Initial setup and ongoing upgrades require real Rails sysadmin skills (Ruby version, database, migrations, plugins, ERB templates), which is beyond what most project managers can handle without IT support.
  • Ecosystem is smaller than Jira — fewer modern SaaS integrations (Slack, GitHub, Bitbucket connectors exist but lag) and no built-in marketplace UX, so connectivity to current toolchains often needs custom work.
  • Self-hosted means the customer also owns backup, uptime, scaling, and security — costs that look invisible on paper but become significant for larger teams, often pushing them to migrate to Jira Cloud, GitLab, or Linear.

Choosing

Jira logo

Jira

What's pulling them in

  • Industry-standard tool with deep Git integration and sprint reporting that engineering teams already know, reducing onboarding friction for new hires.
  • Highly customizable workflows and status schemes let business teams model complex approval chains without writing code.
  • Strong ecosystem of Atlassian Marketplace apps means specialized capabilities like time tracking or portfolio management are one install away.
  • Free tier with up to 10 users and unlimited issues gives small teams a no-cost entry point to validate the platform before committing budget.
  • Visibility features — boards, backlog grooming, sprint reports, and dashboards — give leadership a shared view of what is planned, in progress, blocked, and done.

Object mapping

How Redmine 3.3 objects map to Jira

Each row shows how a Redmine 3.3 object lands in Jira, including any object-level transformations, lookup resolution, or schema-design dependencies.

Typical mapping — final map is confirmed during the sample migration step.

Redmine 3.3

Project

maps to

Jira

Project

1:1
Fully supported

Redmine Projects map to Jira Projects. A Redmine subproject becomes a standalone Jira Project in the same Jira Project Category, preserving the original subproject name and identifier in the Jira Project key for traceability. Module enablement (wiki, repository, forums, time tracking) per Redmine project maps to Jira project features toggled during project creation. The Redmine project identifier (e.g., ACCT) becomes the Jira project key.

Redmine 3.3

Issue

maps to

Jira

Issue

1:1
Fully supported

Redmine Issues migrate to Jira Issues with subject as Summary, description as Description (stored as Atlassian Document Format or plain text depending on the target Jira version), and done_ratio mapped to a Jira custom field percentage__c since Jira Issues do not have a native done ratio on standard fields. Status from Redmine (New, In Progress, Resolved, Feedback, Closed) maps to a Jira workflow status after the destination workflow is configured in Jira's workflow designer. Priority maps directly.

Redmine 3.3

Tracker

maps to

Jira

Issue Type

lossy
Fully supported

Redmine Trackers (Bug, Feature, Support, or custom) configure to Jira Issue Types. We create Issue Type screen schemes per Jira project to map each Redmine Tracker to a Jira Issue Type, ensuring that the correct fields appear for each type after migration. Custom Tracker definitions from plugins require schema auditing before mapping because some plugins store tracker metadata in non-standard tables not surfaced by the REST API.

Redmine 3.3

Version (Target)

maps to

Jira

Version (Affects Version, Fix Version)

1:1
Fully supported

Redmine Versions (milestones or releases within a project, with effective date and description) map to Jira Fix Versions. The Redmine version status (open, locked, closed) maps to a Jira Version status. Jira does not have a direct Affects Version model equivalent for unreleased version tracking, so affected-version tracking uses Fix Version for both directions unless the customer requests a custom Affects Version configuration.

Redmine 3.3

Custom Field (list-format)

maps to

Jira

Custom Field

lossy
Fully supported

Redmine list-format custom fields store numeric internal IDs in the issue record, not display labels. We query the custom_field definitions endpoint and the custom_field_possible_values table to build an ID-to-label lookup table before processing any issue export. Display values are substituted at write time so that Jira receives human-readable values instead of raw integers. Free-text and date custom fields migrate directly without lookup resolution.

Redmine 3.3

Time Entry

maps to

Jira

Worklog

1:1
Fully supported

Redmine Time Entries (hours, activity, comments, spent_on, issue association) map to Jira Worklogs. Redmine's activity field (e.g., Design, Development, Meeting) has no direct Jira equivalent, so we preserve it as a custom field redmine_activity__c on the Jira Issue. Time entries linked to a specific Issue are attached to the migrated Jira Issue; time entries linked to a Project without an issue are attached to the Jira Project's custom project-level worklog field if the Jira project type supports it.

Redmine 3.3

User

maps to

Jira

User

1:1
Fully supported

Redmine user accounts (login, firstname, lastname, email, admin flag) map to Jira user accounts. We match by email address. Redmine role-based membership assignments per project map to Jira project role memberships (Viewer, Member, Admin) based on the Redmine role permissions recorded in the memberships table. Users without a matching Jira account are held in a reconciliation queue for the customer's admin to provision before record import begins.

Redmine 3.3

Issue Relation

maps to

Jira

Issue Link

1:1
Fully supported

Redmine typed issue relations (blocks, blocked by, relates to, duplicates, follows, precedes) map to Jira Issue Link types. We export the full relation graph from Redmine's issue_relations table, then resolve target issue IDs after the Jira Issue IDs are assigned during migration so that links attach to the correct records. Redmine's internal issue ID is preserved in a custom field redmine_issue_id__c for cross-reference during reconciliation.

Redmine 3.3

Attachment

maps to

Jira

Attachment

lossy
Fully supported

Redmine stores uploaded files on the server filesystem under files/ and records file path and metadata in the database. We extract file paths from the attachments table, verify file accessibility, download each file, and re-upload to Jira via the REST API with the same filename and content-type. Files attached to wiki pages or documents are handled as issue attachments after migration since Jira does not have a native wiki structure equivalent.

Redmine 3.3

Wiki Page

maps to

Jira

Confluence Page or Jira Issue Description

lossy
Fully supported

Redmine wikis are project-scoped with page hierarchy and wiki-format content. Jira does not have a native wiki. We export wiki content as structured text and either create Jira issue descriptions (for single-page context) or deliver a written inventory of all wiki content organized by project for the customer to rebuild in Confluence or Jira's native documentation features. Page-level permissions from Redmine cannot be directly mapped to Confluence permissions without a separate permission audit.

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 3.3 logo

Redmine 3.3 gotchas

High

Database migrations are required between major Redmine versions

High

CSV export has no native import counterpart

Medium

Custom field list values store internal IDs, not display labels

Medium

Plugin-specific data is not accessible via the REST API

Medium

Attachment files live on the server filesystem, not the database

Jira logo

Jira gotchas

High

Unsupported workflow validators silently skipped during migration

High

Custom fields converted to flat text labels when migrating to non-Jira platforms

Medium

Historical status-change timestamps lost when exporting without a Marketplace plugin

Medium

Attachment import failures from oversized files and JQL reference corruption

Medium

Points-based API rate limits enforced on Jira Cloud apps from March 2026

Pair-specific challenges

  • Redmine status values do not map directly to Jira workflow statuses

    Redmine 3.3 allows custom status values per project that are not tied to a specific tracker or issue type — a single status can appear across all issue types in a project. Jira requires statuses to be defined within a workflow that is associated with an issue type and a project. The Redmine Importer tool for Jira Server creates a separate custom field for each imported project to track the original Redmine status, and the Eficode migration case study documents that teams had to adjust Jira project templates to include all Redmine statuses before import. We configure the Jira destination workflow with all Redmine status values before migration begins, using a temporary transition status so tickets that cannot be mapped cleanly are held for admin bulk-editing post-migration.

  • Custom fields are created per-import and accumulate across multiple project imports

    The Jira Redmine Importer creates a new custom field for each project import to guard against re-importing the same issues. When migrating multiple Redmine projects into Jira, this results in dozens of redundant custom fields (one per project import) that obscure the actual field mapping and increase Jira administration overhead. The Eficode case study recommends consolidating these into a single custom field using ScriptRunner post-migration. We include a post-migration custom field consolidation step in our scope and provide the consolidation script.

  • Redmine 3.3 has no bulk write API — CSV export sequencing is required

    Redmine 3.3's REST API is read-oriented for most objects. There is no bulk write or bulk import capability within Redmine itself. Teams attempting manual migration via CSV exports encounter field mapping errors especially for custom fields and enum values. We sequence CSV exports in ordered chunks based on dependency (projects first, then users, then versions, then issues with parent-child resolution, then time entries, then attachments), and we resolve custom field ID-to-label lookups before writing to Jira. The Redmine 3.3 REST API can be used to supplement CSV data for users and custom field definitions, but the core data movement relies on structured CSV export sequencing.

  • Redmine plugin data is not accessible via the REST API

    Many Redmine 3.3 installations use third-party plugins for Kanban boards, advanced workflows, or project-specific custom objects. Plugin data in non-standard tables is not surfaced by the core REST API. One documented migration case study (Alex Matveev, 2020) described a 10-year, 100-project, 100,000-issue migration that required learning Ruby to access plugin-isolated data. We audit the source Redmine database schema before migration to identify plugin tables and flag any plugin-isolated data that cannot be safely migrated without manual intervention or a plugin-reinstallation step at the destination.

  • Jira Cloud requires CSV import rather than a direct connector for Redmine

    For Redmine to Jira Cloud migrations, Atlassian's documented method is CSV export from Redmine followed by CSV upload to Jira Cloud. The Jira Server Redmine Importer plugin (which uses direct API connectivity) only works with Jira Server and Jira Data Center, not Jira Cloud. We handle the CSV export sequencing, ID resolution, and Jira Cloud CSV import configuration as part of our standard scope. Jira Cloud's rate limits on CSV import require chunked uploads for large datasets, which we manage as part of the batch sequencing process.

Migration approach

Six steps for a successful Redmine 3.3 to Jira data migration

  1. Source schema audit and plugin table identification

    We audit the Redmine 3.3 database schema to identify all tables containing user data including custom_field definitions, custom_field_possible_values for list-format fields, issue_relations for the relationship graph, and any plugin-specific tables that may contain project data not surfaced by the REST API. We extract the full project tree (including subproject hierarchy), tracker definitions, workflow state mappings, and role-permission assignments. This audit output is a written data inventory that defines exactly what migrates and what is flagged for admin rebuild.

  2. Destination Jira project and workflow configuration

    We create Jira projects for each Redmine project and subproject, configure Jira Issue Types to match Redmine Trackers, and design the Jira workflow to include all Redmine status values. Custom fields are pre-created in Jira with the correct field types before any data is written. We configure Issue Type screen schemes to ensure the correct fields appear for each Redmine Tracker mapped to a Jira Issue Type. This phase requires the customer's Jira admin to confirm the project template and workflow design before we begin data migration.

  3. Custom field ID-to-label lookup table construction

    We query the Redmine custom_field definitions and custom_field_possible_values tables to build the ID-to-label lookup table for every list-format custom field in the source instance. This table is applied during the issue transformation phase so that Jira receives display labels rather than numeric IDs. Free-text, date, boolean, and user-typed custom fields are processed without lookup resolution.

  4. CSV export sequencing and data extraction

    We extract data from Redmine 3.3 in dependency order: projects and subprojects first, then users and memberships, then versions, then issues with parent-child ID preservation, then time entries, then attachments. Each chunk is validated against the source database record count before transformation begins. Issue relation records are extracted separately for post-insertion link resolution. Plugin-isolated data identified during schema audit is flagged and excluded from the automated migration scope.

  5. Sandbox migration and reconciliation

    We run a full migration into a Jira Sandbox or a non-production Jira Cloud environment using production-equivalent data volume. The customer's project manager and admin spot-check migrated issues across each Redmine project, verify that custom field values display correctly, confirm that issue relations appear as Jira issue links, and validate time entry counts. Mapping corrections identified during sandbox reconciliation are applied before production migration begins.

  6. Production migration in dependency order with delta capture

    We run production migration in the same dependency sequence used in sandbox: Projects, Users, Versions, Issues (with parent-child ID resolution), Time Entries, Issue Relations (after Jira Issue IDs are assigned), and Attachments. Each phase emits a row-count reconciliation report. During the migration window, any records modified in Redmine are captured as a delta. We do not migrate Jira Automations, workflows, boards, reports, or dashboards — these are delivered as written inventories for the customer's admin to rebuild in Jira's native tools.

Platform deep dives

Context on both ends of the pair

Redmine 3.3 logo

Redmine 3.3

Source

Strengths

  • Zero licensing cost — fully open-source with no per-user or per-project fees regardless of team size
  • Flexible role-based access control with per-role, per-tracker permission restrictions introduced in 3.3
  • Multi-database support (MySQL, PostgreSQL, SQLite, SQL Server) for on-premises deployment flexibility
  • Integrated time tracking with activity categories and per-user, per-issue reporting
  • Native Gantt chart and calendar views built on issue start and due dates without plugins

Weaknesses

  • No built-in bulk import tool — data movement relies on CSV exports with manual sequencing or third-party plugins
  • REST API in 3.3 is read-oriented for most objects; write operations and bulk endpoints are limited or absent
  • Upgrading Redmine between major versions requires running database migrations that are not always reversible
  • The web UI is considered dated and unpolished compared to modern SaaS alternatives, increasing user onboarding friction
  • Plugin ecosystem is fragmented — many popular plugins are not compatible with newer Redmine major versions
Jira logo

Jira

Destination

Strengths

  • Deeply customizable workflows and status schemes with no hard limits on workflow complexity or number of custom statuses.
  • Strong agile ceremony support: sprint planning, backlog grooming, velocity tracking, and burndown charts for Scrum teams.
  • Industry-standard developer tool with native Git integration linking commits, pull requests, and deployments to issues.
  • Large Atlassian Marketplace with thousands of plugins extending time tracking, portfolio management, and reporting capabilities.
  • Free tier available for up to 10 users with unlimited issues, enabling evaluation before committing to a paid plan.

Weaknesses

  • Excessive configurability creates a steep learning curve; cross-team consistency is hard to maintain without strict governance.
  • Performance degrades with large backlogs, complex custom fields, and heavily nested issue hierarchies.
  • Reporting requires additional configuration or paid plugins; out-of-the-box analytics are limited for business users.
  • Jira lacks native sprint management, requiring Jira Software for true agile team features.
  • Teams outside engineering resist adoption due to UI complexity, leaving the all-in-one promise unfulfilled for cross-functional organizations.

Complexity grading

How hard is this migration?

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

B

Overall complexity

Standard migration

Derived from compatibility, mapping clarity, API constraints, and data volume across Redmine 3.3 and Jira.

  • Object compatibility

    B

    3 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 3.3: Not publicly documented — no published rate limit for self-hosted instances.

  • Data volume sensitivity

    B

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

Estimator

Estimate your Redmine 3.3 to Jira 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 3.3 to Jira data migrations

Answers to the questions buyers ask most during Redmine 3.3 to Jira migration scoping. Not seeing yours? Book a call.

Can't find your answer?

Walk through your Redmine 3.3 to Jira migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Small migrations under 5,000 issues with straightforward field mapping complete in two to four weeks. Mid-size migrations (5,000 to 50,000 issues) land between four and six weeks. Large enterprise migrations with over 50,000 issues, complex subproject hierarchies, or plugin-isolated data requiring schema auditing move to six to ten weeks because of chunked CSV sequencing, parent-child ID resolution, and Jira workflow configuration time.

Adjacent paths

Related migrations to explore

Ready when you are

Move from Redmine 3.3.
Land in Jira, 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