Project Management migration
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
Source
Jira
Destination
Compatibility
6 of 10
objects map 1:1 between Redmine 3.3 and Jira.
Complexity
BStandard
Timeline
2-4 weeks
Overview
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.
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 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
Jira
Project
1:1Redmine 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
Jira
Issue
1:1Redmine 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
Jira
Issue Type
lossyRedmine 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)
Jira
Version (Affects Version, Fix Version)
1:1Redmine 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)
Jira
Custom Field
lossyRedmine 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
Jira
Worklog
1:1Redmine 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
Jira
User
1:1Redmine 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
Jira
Issue Link
1:1Redmine 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
Jira
Attachment
lossyRedmine 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
Jira
Confluence Page or Jira Issue Description
lossyRedmine 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.
| Redmine 3.3 | Jira | Compatibility | |
|---|---|---|---|
| Project | Project1:1 | Fully supported | |
| Issue | Issue1:1 | Fully supported | |
| Tracker | Issue Typelossy | Fully supported | |
| Version (Target) | Version (Affects Version, Fix Version)1:1 | Fully supported | |
| Custom Field (list-format) | Custom Fieldlossy | Fully supported | |
| Time Entry | Worklog1:1 | Fully supported | |
| User | User1:1 | Fully supported | |
| Issue Relation | Issue Link1:1 | Fully supported | |
| Attachment | Attachmentlossy | Fully supported | |
| Wiki Page | Confluence Page or Jira Issue Descriptionlossy | 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 3.3 gotchas
Database migrations are required between major Redmine versions
CSV export has no native import counterpart
Custom field list values store internal IDs, not display labels
Plugin-specific data is not accessible via the REST API
Attachment files live on the server filesystem, not the database
Jira gotchas
Unsupported workflow validators silently skipped during migration
Custom fields converted to flat text labels when migrating to non-Jira platforms
Historical status-change timestamps lost when exporting without a Marketplace plugin
Attachment import failures from oversized files and JQL reference corruption
Points-based API rate limits enforced on Jira Cloud apps from March 2026
Pair-specific challenges
Migration approach
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.
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.
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.
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.
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.
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
Redmine 3.3
Source
Strengths
Weaknesses
Jira
Destination
Strengths
Weaknesses
Complexity grading
Standard Project Management migration. 3 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 3.3 and Jira.
Object compatibility
3 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 3.3: Not publicly documented — no published rate limit for self-hosted instances.
Data volume sensitivity
Redmine 3.3 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 3.3 to Jira migration scoping. Not seeing yours? Book a call.
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 consultationAdjacent paths
Other ways to leave Redmine 3.3
Other ways to arrive at Jira
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.