Project Management migration
Field-level mapping, validation, and rollback between Redmine 3.3 and Asana. We move data and schema; workflows are rebuilt natively in Asana.
Redmine 3.3
Source
Asana
Destination
Compatibility
6 of 12
objects map 1:1 between Redmine 3.3 and Asana.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Redmine 3.3 stores project hierarchies, issue workflows, and time entries in a self-hosted Rails 4.2 database with a read-oriented REST API and no native bulk import capability. Asana uses a cloud-native workspace-team-project-task model with custom fields, Timeline views, and a real-time API. The structural differences are significant: Redmine's subproject nesting must map to Asana's project hierarchy or team structure, its issue-status workflow states have no direct Asana equivalent and become task Status fields, and its tracker types (Bug, Feature, Support) become custom field dropdowns or project sections. We resolve Redmine's custom field list IDs to display labels before writing to Asana, download attachment files from the Redmine server filesystem and re-upload to Asana task attachments, and translate Redmine's typed issue relations (blocks, blocked by, relates to) into Asana dependency arrows on the Timeline view. We do not migrate Redmine workflows, wiki pages (Asana has no wiki concept), or plugin-specific data that lives in non-standard database tables.
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 Asana, 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
Asana
Project or Team
lossyRedmine projects map to Asana Projects within Teams. Redmine's subproject hierarchy (a project with a parent project_id) maps to Asana's project nesting or a separate project within the same Team. If the Redmine instance uses many levels of subproject nesting, we discuss collapsing into a flat project-per-team structure or using Asana Portfolios for cross-project grouping. The project's public/private flag maps to the Asana project's visibility setting. Each Redmine project module (wiki, forums, repository, time tracking) is audited and flagged: Asana has no wiki or forum equivalent, so those are omitted from the migration scope unless the customer requests wiki-to-task conversion.
Redmine 3.3
Issue
Asana
Task
1:1Redmine issues map directly to Asana tasks. Subject maps to Task Name, Description maps to the task description field (markdown preserved), Done Ratio maps to a custom numeric field or Percent Complete if using the Asana Timeline. Start Date and Due Date map to the task Start Date and Due Date fields. Redmine's issue priority (Low, Normal, High, Urgent) maps to Asana's Custom Fields as a single-select dropdown. Redmine's estimated hours map to Asana's Time Tracking field if the project has it enabled. We resolve assignee (issue.assigned_to_id) by matching to an Asana User by email.
Redmine 3.3
Tracker
Asana
Custom Field (dropdown) or Section
lossyRedmine trackers (Bug, Feature, Support, or custom trackers defined at install time) do not have a native Asana equivalent. We create an Asana custom field named 'Tracker' with a single-select dropdown containing each distinct tracker name from Redmine, then write the tracker value into that field for each migrated task. Alternatively, if the customer prefers a non-custom-field approach, we create one Asana Section per tracker within each project and sort migrated issues into those sections.
Redmine 3.3
Custom Field (list-format)
Asana
Custom Field (single-select or multi-select)
lossyRedmine 3.3 stores list-format custom field values as internal numeric IDs in the issue record, while the human-readable label lives in a separate possible_values table. We query the custom_field definitions endpoint and build an ID-to-label lookup table before processing any issue export. For each list-format custom field, we create a corresponding Asana custom field of the matching type (single-select for list, multi-select for multi-list) and write the resolved display label rather than the raw ID. This prevents migrated records from showing numeric IDs instead of meaningful values.
Redmine 3.3
Time Entry
Asana
Task (with time tracking)
1:1Redmine time entries record hours spent against a project or specific issue, with activity categories (e.g., Development, Design, Meeting) and comments. Asana's time tracking feature is enabled at the project level and records time against tasks. We migrate time entries by converting the Redmine hours and activity into Asana time logged against the corresponding task. If Asana time tracking is not enabled on the destination project, we create a custom numeric field 'Hours Logged' and write the total hours there, losing the per-activity breakdown. Activity category names migrate as a custom field on the task if the customer requires the breakdown.
Redmine 3.3
Version
Asana
Milestone
1:1Redmine versions (or targets) represent milestones or releases within a project, with fields for name, effective date, description, and status. Asana Milestones are a task type with zero duration that represent checkpoints. We migrate each Redmine version as an Asana Milestone within the corresponding project. The version effective date maps to the milestone due date, and the version description migrates to the milestone description. If the Redmine version is not yet effective (status = 'open'), the milestone is created without a due date.
Redmine 3.3
Issue Relation
Asana
Task Dependency
1:1Redmine supports typed issue relations: blocks, blocked by, relates to, duplicates, and others. Asana Timeline supports dependency types finish-to-start, start-to-start, finish-to-finish, and start-to-finish. We map Redmine 'blocks' to Asana 'blocks' (finish-to-start where the blocking task must complete before the dependent starts), 'blocked by' to 'depends on', 'relates to' to a non-blocking association (noted in the task description because Asana has no non-blocking dependency type), and 'duplicates' to a task-level flag. Circular dependency detection is applied during the transform phase.
Redmine 3.3
Attachment
Asana
Task Attachment
1:1Redmine stores uploaded files on the server filesystem under the files/ directory (or a configured storage path) and records only the file path and metadata in the attachments table. We extract file paths from the attachments table, verify file accessibility on the Redmine server, download each file, and re-upload to Asana as a task attachment via the Asana Attachments API. The original filename and content-type are preserved so that the attached file opens correctly in Asana. Files are processed in batches to manage download/upload time and avoid timeout during the migration window.
Redmine 3.3
User and Membership
Asana
Team Member
1:1Redmine user accounts include login, firstname, lastname, email, admin flag, and custom fields. We export users and their project memberships with role assignments. We match Redmine users to Asana workspace members by email address. If a Redmine user has no corresponding Asana account, they are added to a reconciliation list for the customer to provision before record import. Role-based access control (Redmine role permissions per project) has no direct Asana equivalent; we document the role matrix in the migration handoff and the customer recreates permissions in Asana Teams and Projects manually.
Redmine 3.3
Wiki Page
Asana
Not migrated
lossyRedmine wikis are project-scoped and store content in a wiki_format attribute with page hierarchy. Asana has no wiki or document-repository concept. We do not migrate wiki pages as functional content. We export wiki content as HTML files and deliver them as a static export package. If the customer uses Redmine wiki for project documentation, they must recreate it in a document management tool (Notion, Confluence, Google Docs) or in Asana task descriptions. This is flagged during discovery and documented in the scope agreement before migration begins.
Redmine 3.3
Document
Asana
Task Attachment or Not migrated
lossyRedmine project-level documents store a title, description, and category with attached files. If the document has files attached, we migrate those files as task attachments on a designated documentation task within the project. If the document has no attachments, it is flagged as a candidate for recreation in a document management tool. Document categories vary by installation and do not have an Asana equivalent.
Redmine 3.3
News
Asana
Not migrated
lossyProject news posts include a title, summary, content, and author. Asana has no news feed equivalent. News is omitted from standard migration scope as it is typically lower priority than task and project data. If explicitly requested, we migrate news as tasks with a custom 'News' section and the author set as the task assignee.
| Redmine 3.3 | Asana | Compatibility | |
|---|---|---|---|
| Project | Project or Teamlossy | Fully supported | |
| Issue | Task1:1 | Fully supported | |
| Tracker | Custom Field (dropdown) or Sectionlossy | Fully supported | |
| Custom Field (list-format) | Custom Field (single-select or multi-select)lossy | Fully supported | |
| Time Entry | Task (with time tracking)1:1 | Fully supported | |
| Version | Milestone1:1 | Fully supported | |
| Issue Relation | Task Dependency1:1 | Fully supported | |
| Attachment | Task Attachment1:1 | Fully supported | |
| User and Membership | Team Member1:1 | Fully supported | |
| Wiki Page | Not migratedlossy | Fully supported | |
| Document | Task Attachment or Not migratedlossy | Fully supported | |
| News | Not migratedlossy | 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 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
Asana gotchas
Automation rules have no export representation
API rate limits cap bulk migration throughput
Portfolios are view-only objects that do not hold data
Custom field enum options cannot be updated via API
Subtasks do not appear in project views by default
Pair-specific challenges
Migration approach
Discovery and source audit
We audit the Redmine 3.3 database schema directly (via a read-only SQL connection or CSV export of all relevant tables) to capture all projects, subprojects, issues, trackers, custom field definitions, time entries, versions, attachments, users, and memberships. We identify plugin-specific tables that extend the core schema and flag any plugin-isolated data as out of scope. We document the project hierarchy depth, custom field count, total attachment file size, and time entry volume to produce a migration scope and timeline estimate.
Custom field ID resolution and transform design
We query the custom_field definitions table to retrieve all list-format custom fields and their possible_values. We build an ID-to-label lookup map for every list-format field. We also capture any enumeration format custom fields (checkboxes, radio buttons) and map them to Asana single-select or multi-select custom fields of the corresponding type. The transform design document is reviewed with the customer before any data is written to Asana.
Asana workspace and project structure setup
We create the Asana workspace structure to receive the Redmine data. This includes provisioning Teams (if the Redmine project count warrants team-level grouping), Projects per Redmine project, enabling time tracking on projects where time entries are in scope, creating custom field definitions (Tracker, Priority, and any resolved Redmine custom fields) as single-select or multi-select dropdowns, and creating Milestone custom fields for Redmine versions. The structure is validated in Asana before migration begins.
Sandbox migration and reconciliation
We run a full migration into an Asana workspace using production-equivalent data volume. The customer reconciles record counts (projects in, tasks in, custom field values populated, attachments count), spot-checks 25-50 randomly sampled tasks against the Redmine source for field accuracy, and verifies that subproject hierarchy, assignee resolution, and attachment links are correct. Mapping corrections are applied here, not in production.
Attachment extraction and re-upload
We extract file paths from the Redmine attachments table, verify each file is accessible on the server or storage backend, download files in batches, and re-upload to Asana tasks via the Asana Attachments API. We match attachments to tasks by issue_id, preserve the original filename and content-type, and record the upload confirmation in the migration manifest. Any inaccessible files or path errors are logged for manual resolution.
Production migration in dependency order
We run production migration in record-dependency order: Team and project structure first, then versions as milestones, then issues as tasks (with custom fields resolved from ID to label), then issue relations as Timeline dependencies, then time entries against tasks, then attachments. Each phase emits a row-count reconciliation report before the next phase begins. After all data is written, we run a dependency graph validation to flag any unresolved red arrows from the known Asana Timeline quirk.
Cutover, validation, and handoff
We freeze Redmine writes during cutover, run a delta migration of any records modified during the migration window, then enable Asana as the system of record. We deliver the workflow inventory document (documenting Redmine tracker permission restrictions and workflow state transitions for the admin to evaluate), the wiki HTML export, and the role matrix documentation. We support a one-week hypercare window for reconciliation issues. We do not rebuild Redmine workflows as Asana automations inside the migration scope; that is a separate engagement.
Platform deep dives
Redmine 3.3
Source
Strengths
Weaknesses
Asana
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 3.3 and Asana.
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 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 Asana migration scoping. Not seeing yours? Book a call.
Walk through your Redmine 3.3 to Asana 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 Asana
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.