---
title: "Jira to Asana Migration: Field Mapping & Rollback"
description: "Migrate Jira to Asana with FlitStack AI: field-level mapping, a sample run you approve, full history and one-click rollback."
url: "https://flitstack.ai/migrations/pm/jira/to/asana"
---

# Jira to Asana migration

Moving from Jira to Asana is a common consolidation path when cross-functional teams outgrow Jira's developer-centric interface. FlitStack AI maps every Jira project, issue, epic, subtask, story-point value, and attachment into Asana — preserving assignee history, original create dates, and sprint labels as custom fields so your Asana workspace reflects your Jira state from day one.

Short answer

FlitStack AI migrates projects, tasks, subtasks, task or projects and section or custom enum fields from Jira to Asana, with their history and the associations between records. Every field is mapped and validated, a sample run is checked with you before the full migration, and the whole move can be rolled back in one click. Typical timeline: 3–7 days for under 5,000 issues across 1–5 Jira projects.

![](https://flitstack.ai/images/authors/aditya-kumar.webp)By [Aditya Kumar](https://flitstack.ai/about/aditya-kumar) Updated November 5, 2026

[Get a quote ](https://flitstack.ai/contact) [See the field mapping →](https://flitstack.ai/migrations/pm/jira/to/asana#field-mapping)

![](https://flitstack.ai/images/illustrations/pair-stage.webp)

Source Jira ![](https://flitstack.ai/platforms-trim/jira.webp)

Destination Asana ![](https://flitstack.ai/platforms-trim/asana.webp)

Project Task Subtask Task or Project Section or Custom enum field

Mapped field by field · sample run · one-click rollback

## What moves from Jira to Asana?

Jira organizes work as Projects containing Issues with types (Bug, Story, Task, Epic, Sub-task), a configurable workflow engine driving status transitions, native sprint tracking tied to boards, and a rich linking model (blockers, clones, duplicates).

Read the full summary

Asana organizes work as Projects containing Tasks with a flat status model, no native sprint concept, and only finish-to-start dependency tracking. These structural differences shape every field mapping decision in the migration. We map Jira Issues to Asana Tasks — the summary becomes the task name, the description becomes task notes, assignee resolves directly, and reporter becomes a custom field since Asana has no native reporter concept. Jira issue type, priority, labels, and story points migrate as custom fields. Jira custom fields map 1:1 when Asana supports the type (enum, text, number, date, people, checkbox); unsupported types fall back to text. Comments, attachments, and subtasks migrate intact. Linked Jira issues become Asana dependencies where the relationship is finish-to-start; all other link types are preserved as a custom text field. Jira workflows, automation rules, and transition post-functions cannot migrate — Asana's Workflow Builder uses a different trigger-action model. We export Jira workflow definitions as a reference document so your team can rebuild them. Jira's sprint velocity and burndown data also requires manual reconstruction in Asana using custom fields or a third-party reporting integration. The migration uses Jira's bulk-export API and Asana's REST API, sequenced so parent tasks exist before subtasks and projects exist before their issues.

direct

### Project → Project

Jira Project maps 1:1 to Asana Project.

How it maps

Project key, name, lead owner, project description, and any default settings transfer directly. Project-level configurations such as notification scheme, permission scheme, and issue security scheme have no Asana equivalent and are documented during the audit phase for manual re-setup after migration completes.

transformed

### Issue (Bug, Story, Task, Epic) → Task

Every Jira issue type becomes a Task in Asana.

How it maps

The issue type itself does not exist natively in Asana — it migrates as a custom enum field (Issue\_Type\_\_c) with Jira's five type values as options. Every Asana task shows this field after migration.

direct

### Sub-task → Subtask

Jira Sub-task maps directly to an Asana Subtask, preserving the parent-child relationship intact.

How it maps

Jira requires the parent issue to exist before the subtask can be created — we sequence the migration so parent issues migrate first and subtasks follow in a second pass to maintain referential integrity throughout the data transfer.

custom\_field\_required

### Epic → Task (parent) or Project

Jira Epics can be handled two ways: as parent Tasks with child Stories as Subtasks within that parent, or elevated to Asana Projects with Stories as Tasks under the project.

How it maps

Teams choose the mapping strategy during planning based on their Asana workspace structure and how they want to view epic-level progress in list, board, or timeline views.

value\_mapping

### Issue Status → Section (List/Board) or Custom enum field

Jira status values (To Do, In Progress, In Review, Done) map to Asana Sections in List/Board view.

How it maps

The mapping is value-by-value based on Jira workflow configuration. Status transitions and conditions do not transfer — only the final status value lands in Asana.

value\_mapping

### Priority → Custom enum field (Priority\_\_c)

Jira Priority field values (Highest, High, Medium, Low, Lowest) map to a custom enum field in Asana.

How it maps

Each Jira Priority value maps to the matching Asana enum option by name and display order. The priority hierarchy and relative weight are preserved in the custom field definition so reports and filters work identically.

******What moves 15 objects

Jira Asana

- Project Project 1:1
- Issue Task transformed
- Sub-task Subtask 1:1
- Epic Task or Project transformed
- Issue Status Section or Custom enum field transformed
- Priority Custom enum field transformed

\+ 9 more in the mapping below

## How Jira and Asana differ

The differences that decide how each record is mapped. These are what a CSV export and a native importer don't resolve for you.

| Dimension           | Jira                                                                                     | Asana                                                                                                  |
| ------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| Work unit structure | Project → Issue (Bug, Story, Task, Epic, Sub-task) with type-specific schemas            | Project → Task; no native issue-type distinction — simulated via custom field                          |
| Status model        | Workflow-driven transitions with conditions, validators, and post-functions              | Static status via Sections (List/Board view) or custom enum field; no stateful transitions             |
| Sprint tracking     | Native sprint object tied to board; tracks start/end dates, velocity, and burndown       | No native sprint concept; sprint name and dates stored as custom text field or tag                     |
| Issue type handling | Five built-in types with type-specific field schemas and screens                         | All work items are Tasks; type distinction requires custom enum field on every task                    |
| Estimation units    | Story points (native numeric field) or time tracking with worklog entries                | Story points migrate as custom Number field; time tracking has no native equivalent                    |
| Issue relationships | Linked issues with types: blocker, clone, duplicate, is duplicated by, custom link types | Native dependencies only support finish-to-start blocking; all other link types lost or stored as text |
| Automation          | Automation for Jira: conditions, validators, post-functions, and global flows            | Asana Workflow Builder: simple trigger-action rules; no equivalent to stateful transitions             |
| Time tracking       | Native worklog with time spent, date, and author per issue                               | No native time-tracking; worklog preserved as custom text field for reference only                     |

## Jira to Asana field mapping

The 25 most-used fields of 25 mapped for this pair. Custom fields are added from your own schema during scoping. [Download the full mapping (CSV) ↓](https://flitstack.ai/migrations/pm/jira/to/asana.csv) or open it in the [field mapping template](https://flitstack.ai/tools/field-mapping-template).

******Field mapping 5 shown

Jira Asana

1. `summary` Issue `name` Task
2. `description` Issue `notes` Task
3. `status` Issue `section_name` Task
4. `priority` Issue `Priority__c` Task
5. `issuetype` Issue `Issue_Type__c` Task

| Jira field              | Asana field                | Mapping                 | Note                                                                                                                                              |
| ----------------------- | -------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Issue.summary`         | `Task.name`                | direct                  |                                                                                                                                                   |
| `Issue.description`     | `Task.notes`               | direct                  | HTML in Jira description is converted to plain text with paragraph breaks preserved.                                                              |
| `Issue.status`          | `Task.section_name`        | value\_mapping          | Jira status values map to Asana Section names by value. Workflow transition rules do not transfer.                                                |
| `Issue.priority`        | `Task.Priority__c`         | value\_mapping          | Jira priority (Highest, High, Medium, Low, Lowest) maps to a custom enum field with matching option names.                                        |
| `Issue.issuetype`       | `Task.Issue_Type__c`       | value\_mapping          | Jira's five issue types (Bug, Story, Task, Epic, Sub-task) become enum options in a custom field. All tasks show this field.                      |
| `Issue.creator`         | `Task.Created_By__c`       | custom\_field\_required | Asana has no native creator field; creator name and email migrate as a read-only custom text field.                                               |
| `Issue.created`         | `Task.Created_Date__c`     | custom\_field\_required | Jira's Created timestamp preserves the original date; stored as a custom datetime field since Asana's created\_at is migration-time.              |
| `Issue.updated`         | `Task.Updated_Date__c`     | custom\_field\_required | Jira's last-updated timestamp preserved as a custom datetime field for audit continuity.                                                          |
| `Issue.resolutiondate`  | `Task.Resolved_Date__c`    | custom\_field\_required | Jira resolution date stored as a custom datetime. Null values in unresolved issues remain blank.                                                  |
| `Issue.assignee`        | `Task.assignee`            | direct                  |                                                                                                                                                   |
| `Issue.reporter`        | `Task.Reporter__c`         | custom\_field\_required | Asana has no native reporter field; reporter name and email migrate as a custom text field.                                                       |
| `Issue.labels`          | `Task.tags`                | direct                  | Jira labels become Asana tags. Tags are workspace-level. Multiple labels per issue create multiple tags.                                          |
| `Issue.component`       | `Task.Component__c`        | custom\_field\_required | Jira component names stored as a custom text field. Multiple components concatenated with semicolon delimiter.                                    |
| `Issue.sprint`          | `Task.Sprint__c`           | custom\_field\_required | Sprint name and dates stored as custom text. Jira sprint velocity and burndown data cannot transfer to Asana.                                     |
| `Issue.fixversion`      | `Task.Fix_Version__c`      | custom\_field\_required | Fix version names stored as custom text field. Multiple versions concatenated with comma delimiter.                                               |
| `Issue.affectedversion` | `Task.Affected_Version__c` | custom\_field\_required | Affected version names stored as custom text field.                                                                                               |
| `Issue.issuelinks`      | `Task.Linked_Issues__c`    | custom\_field\_required | Non-dependency links stored as custom text. Format: '\[link\_type] Jira-KEY'. Finish-to-start blockers may also create native Asana dependencies. |
| `Issue.worklog`         | `Task.Worklog__c`          | custom\_field\_required | Worklog entries concatenated into one custom text field per issue: 'Xh Ym — \[author] on \[date]' per entry.                                      |
| `Issue.story_points`    | `Task.Story_Points__c`     | custom\_field\_required | Jira story points migrate as a custom Number field. Only populated on Story issues unless your team used points on other types.                   |
| `Issue.duedate`         | `Task.due_date`            | direct                  |                                                                                                                                                   |
| `Issue.project`         | `Task.Project_ID__c`       | custom\_field\_required | Jira project key stored as custom text for traceability. Actual parent project assignment handled at object level.                                |
| `Issue.resolution`      | `Task.Resolution__c`       | value\_mapping          | Jira resolution values (Fixed, Won't Fix, Duplicate, Cannot Reproduce) map to custom enum options.                                                |
| `Issue.environment`     | `Task.Environment__c`      | custom\_field\_required | Jira environment field (often used for deployment context) migrates as a custom text field appended to task notes.                                |
| `Issue.parent`          | `Task.parent`              | direct                  | Jira Sub-task parent ID resolves to Asana parent Task ID. Parent must migrate before subtask.                                                     |
| `Issue.securitylevel`   | `Task.Security__c`         | custom\_field\_required | Jira security levels (if used) map to a custom text field in Asana. Asana permissions handle access control differently.                          |

## What to watch for in a Jira to Asana migration

The issues we plan around on this pair: limits and data-model gaps that the official import tools leave to you.

medium

### Jira issue types require custom field simulation — every task shows the field

Jira has five built-in issue types (Bug, Story, Task, Epic, Sub-task) with type-specific screens, fields, and workflows.

How we handle it

Asana has no native issue-type concept — every work item is a Task. We create a custom enum field (Issue\_Type\_\_c) with the five Jira issue types as options and map each issue at migration time. The trade-off: every Asana task shows this custom field after migration, even if only Stories or Bugs used issue-type differentiation in Jira. Value-by-value mapping of Jira issue types to Asana enum options is included in the migration plan before data moves.

high

### Jira workflows and automation rules cannot migrate to Asana Workflow Builder

Jira workflows automate transitions between statuses using conditions, validators, and post-functions that enforce business rules at each transition point.

How we handle it

A Jira status like 'In Review' may have three valid preceding statuses depending on the current workflow state. Asana's Workflow Builder uses a simple trigger-action model (when X happens, do Y) with no concept of stateful transition logic. Status values migrate — the final state of every Jira issue lands correctly in Asana — but the transition rules, conditions, and post-functions do not. Workflow definitions must be rebuilt as Asana Workflow Builder rules; FlitStack exports Jira workflow definitions as a reference document for this rebuild.

medium

### Jira sprints have no native Asana equivalent — velocity and burndown data requires manual reconstruction

Jira sprints are native objects tied to boards, tracking start date, end date, sprint state, velocity, and burndown charts with issue completion trends.

How we handle it

In Asana, sprints are not a first-class concept. The sprint name and dates can be preserved as a custom text field on tasks, but sprint velocity, burndown trends, and the retrospective data that Jira calculates automatically have no equivalent in Asana. Teams relying on Jira's sprint metrics for reporting will face a gap — velocity must be recalculated manually or reconstructed with third-party reporting tools. We document every sprint's name and dates during migration so the reference data is available.

medium

### Jira linked issues with non-dependency link types lose semantic meaning

Jira supports multiple issue relationship types: blocker (blocks), clone, duplicate, is duplicated by, custom link types, and outward/inward references.

How we handle it

Asana's native dependency feature only supports finish-to-start blocking relationships (Task A must finish before Task B starts). Blocker links where Issue A blocks Issue B map cleanly to an Asana Dependency. All other link types — clone, duplicate, is duplicated by, and any custom link types — have no Asana equivalent and are preserved as a custom text field (Linked\_Issues\_\_c) in the format '\[link\_type] Jira-KEY'. This preserves the reference but loses the semantic enforcement that Jira's linking model provides.

medium

### Jira time tracking and worklog requires manual reconstruction in Asana

Jira's native time-tracking model stores worklog entries per issue — each entry captures time spent, the date, and the author.

How we handle it

Jira then calculates remaining estimate and time-to-completion. Asana has no native time-tracking model. Worklog data can be preserved as a custom text field on each task (format: '3h 30m — jane\@company.com on 2025-11-15'), but this field is read-only reference data — it does not drive any Asana reporting, workload, or capacity views. Teams that use Jira time tracking for billing, capacity planning, or sprint velocity calculations need to rebuild this in Asana using third-party integrations or manual processes.

## How the migration runs

1. ### Audit Jira projects and generate custom field schema for Asana

   Before data moves, we run a full audit of the Jira export — every project, issue type, status value, custom field, label, component, sprint, and link type is catalogued.

   What this step covers

   From this audit we generate an Asana setup plan: a list of every custom field to create (with enum options for picklist fields, field type for all others), the section structure per project, and the label-to-tag taxonomy. This plan is reviewed and approved before any Asana setup begins.

2. ### Set up Asana workspace: projects, custom fields, and tag taxonomy

   We create the Asana workspace structure based on the approved setup plan: Jira Projects become Asana Projects, custom fields are created with correct types and enum options, and the tag taxonomy is populated with migrated labels.

   What this step covers

   Jira users are matched to Asana users by email address. Any Jira users who do not have an Asana account are flagged before migration — your team either creates their Asana account or assigns their issues to a fallback user before the full run.

3. ### Run a sample migration with field-level diff on 50–200 representative issues

   A representative slice of Jira issues — spanning each issue type, each Jira project, and each status value — migrates first.

   What this step covers

   We generate a field-level diff between the source Jira record and the destination Asana task so you can verify every mapping: issue type to custom enum field, priority values, label-to-tag conversion, sprint field, linked-issue preservation, and assignee resolution. You review the diff before the full run commits. Any mapping corrections are applied before the next migration attempt.

4. ### Execute full migration with delta-pickup window and audit log

   Full migration runs against the Asana API, loading issues project by project with parent tasks created before subtasks and Jira project context established before individual issues.

   What this step covers

   A delta-pickup window (24–48 hours) captures any Jira issues created or modified during the cutover. Jira internal IDs are preserved in Asana as a custom field (Jira\_Issue\_ID\_\_c) for traceability and de-duplication. Every migrated record appears in an audit log with source Jira ID, destination Asana task GID, and timestamp. One-click rollback is available if reconciliation uncovers mapping errors.

5. ### Export Jira workflow definitions as rebuild reference

   Jira workflows, automation rules, and transition post-function definitions are exported as a reference document — screen captures of the workflow diagram, transition conditions, and automation rule configurations — so your Asana admin can rebuild them in Asana's Workflow Builder.

   What this step covers

   Workflows are not migrated; the export is the reconstruction guide. Teams relying heavily on Jira's automation engine should expect a rebuild effort proportional to the number of active automation rules.

![](https://flitstack.ai/platforms/jira.svg) Jira ![](https://flitstack.ai/platforms/asana.svg) Asana

1. Connect
2. Map
3. Sample
4. Migrate
5. Verify

- **Contacts** 48,210 / 48,210 Done
- **Companies** 9,134 / 9,134 Done
- **Deals** 6,377 / 11,920 In progress

Example run

******Restore points · Asana Rollback ready

1. Before sample run Restore point 01 Restore
2. Before full migration Restore point 02 Restore
3. After verification Restore point 03 Current

Example

## How long it takes, and what drives the quote

**3–7 days for under 5,000 issues across 1–5 Jira projects** Typical, smaller accounts

**2–3 weeks for over 50,000 issues or complex multi-project setups with sprint data and linked-issue migration** Large or heavily customised accounts

A quote scales with Jira project count, total issue volume, and schema complexity. Base fee covers one Jira project with up to 1,000 issues and a standard set of custom fields. Each additional Jira project adds scope because each project may use different issue types, workflows, and custom field configurations. High custom-field counts (more than 10 per issue type) require more mapping work and push toward the upper range. Handling story points, sprint labels, and linked-issue data as custom fields adds minor complexity. A representative 100-issue test migration is included in every engagement before the full run commits. Every quote is scoped with you; there is no self-serve pricing.

[Get a quote for Jira to Asana →](https://flitstack.ai/contact)

## Why teams move from Jira to Asana

- Jira's interface is built for software developers, and cross-functional teams — marketing, design, operations — often need a work management tool that non-technical stakeholders can use without training. Asana's interface reduces the friction that comes when product managers, designers, and business leads try to track work in a tool designed around issue types and sprint ceremonies.
- As organizations grow their Atlassian footprint — Jira, Confluence, Jira Service Management, Atlassian Intelligence — licensing costs compound. Consolidating project and task work into Asana while keeping Confluence for documentation reduces the per-seat Atlassian spend and simplifies the vendor relationship.
- Jira's strength is requirements traceability and test management for software teams, but when those capabilities aren't being used — or are duplicated by a separate tool — the license cost isn't justified. Moving to Asana for day-to-day work management while keeping Confluence for technical documentation addresses the actual usage pattern.
- Some teams find Jira's complex permission schemes, project schemes, and issue-level security intimidating for simple project tracking. Asana's permission model is simpler — member-level access per workspace — and reduces the administrative overhead of managing who can see and edit what.

Questions, answered

## Jira to Asana migration questions

How long does a Jira to Asana migration take?

Jira to Asana migrations typically complete in 3–7 days of clock time for under 5,000 issues across 1–5 Jira projects. Larger migrations with 50,000+ issues or complex multi-project configurations with sprint data and linked-issue preservation extend to 2–3 weeks. The longest planning step is the Jira audit — identifying all issue types, custom fields, and link types — followed by Asana custom field schema setup before data moves.

Will my Jira workflows migrate to Asana Workflow Builder?

No. Jira workflows automate transitions using conditions, validators, and post-functions that enforce business rules at each transition step. Asana's Workflow Builder uses a simple trigger-action model that cannot replicate Jira's stateful transition logic. Only the final status value of each Jira issue transfers — the transition rules, conditions, and post-functions do not. FlitStack exports Jira workflow definitions as a reference document so your team can rebuild them in Asana's Workflow Builder after migration.

What happens to Jira sprints in Asana?

Jira sprint names and start/end dates migrate as a custom text field (Sprint\_\_c) on each task. Sprint velocity, burndown data, and the retrospective metrics that Jira calculates automatically have no native Asana equivalent. Teams relying on Jira's sprint metrics for reporting face a gap — velocity must be recalculated manually or reconstructed with third-party reporting tools after migration. We document every sprint's name and dates during migration so the reference data is available for reconstruction.

Do Jira issues map directly to Asana tasks?

Yes — Jira issues map to Asana tasks with direct field mappings for name, notes, assignee, due date, and attachments. Reporter becomes a custom field since Asana has no native reporter concept. Jira custom fields map 1:1 when Asana supports the field type (enum, text, number, date, people, checkbox); unsupported types like cascading selects fall back to text. Story points become a custom Number field, components and sprint labels become text fields, and Jira linked issues become either native Asana dependencies or a custom text field depending on the relationship type.

Can Jira issue links (blockers, duplicates) transfer to Asana?

Jira blocker links (Issue A blocks Issue B) map to Asana native dependencies when the relationship is finish-to-start. All other Jira link types — clone, duplicate, is duplicated by, and custom link types — have no Asana equivalent and are preserved as a custom text field (Linked\_Issues\_\_c) in the format '\[link\_type] Jira-KEY'. This preserves the reference for manual review but does not enforce the relationship in Asana's dependency graph. Jira's semantic linking model is partially lost in the migration.

Does the migration affect my Jira account during cutover?

No. FlitStack AI uses scoped read access on Jira — your team continues working in Jira throughout the migration. A delta-pickup window (24–48 hours after the initial export) captures any issues created or modified in Jira during the cutover. Jira internal IDs are preserved in Asana as a custom field, so any duplicate issues detected during delta pickup are flagged and skipped. Jira permissions, project schemes, and issue-level security are not affected by the read-only export.

What happens to Jira time tracking and worklog in Asana?

Jira worklog entries (time spent, date, author per issue) have no native Asana equivalent. The total logged time per issue migrates as a custom text field in the format '3h 30m — jane\@company.com on 2025-11-15'. This field is read-only reference data — it does not appear in Asana's workload, capacity, or reporting views. Teams using Jira time tracking for billing, capacity planning, or sprint velocity calculations need to rebuild this in Asana using third-party integrations or manual processes.

Can Jira custom fields migrate to Asana custom fields?

Yes, Jira custom fields migrate to Asana custom fields when Asana supports the equivalent type. Enum fields map to Asana enum custom fields with value-by-value mapping of Jira options. Text, number, date, and people fields map directly. Jira field types without an Asana equivalent — cascading selects, group pickers, and read-only fields — fall back to a custom text field. Jira custom fields that use a configured default value get that default applied in Asana if the value matches an existing enum option.

## Related migrations

[![](https://flitstack.ai/platforms-trim/asana.webp) Migrate to **Asana** Every source we move into Asana, native options and the checklist. Guide, checklist & sources ](https://flitstack.ai/migrations/pm/asana) [**Asana to Jira** The same pair in reverse](https://flitstack.ai/migrations/pm/asana/to/jira) [**Slack to Asana** Mapping · history · rollback](https://flitstack.ai/migrations/pm/slack/to/asana) [**Airtable to Asana** Mapping · history · rollback](https://flitstack.ai/migrations/pm/airtable/to/asana) [**ClickUp to Asana** Mapping · history · rollback](https://flitstack.ai/migrations/pm/clickup/to/asana) [**Notion to Asana** Mapping · history · rollback](https://flitstack.ai/migrations/pm/notion/to/asana) [**Trello to Asana** Mapping · history · rollback](https://flitstack.ai/migrations/pm/trello/to/asana) [**Jira to monday Work Management** Mapping · history · rollback](https://flitstack.ai/migrations/pm/jira/to/monday-work-management) [**Jira to Trello** Mapping · history · rollback](https://flitstack.ai/migrations/pm/jira/to/trello)

## Sources: official documentation

1. [Prepare data for CSV import — Asana Help Center](https://help.asana.com/s/article/preparing-data-for-csv-import?language=en_US)
2. [Asana CSV Importer — Asana Apps](https://asana.com/apps/csv-importer)
3. [Import data from other tools to projects in Asana — Asana Help Center](https://help.asana.com/s/article/import-data-from-other-tools-to-projects-in-asana?language=en_US)
4. [How to Import CSV Files into Asana — Asana Help Center](https://help.asana.com/s/article/how-to-import-csv-files-into-asana)
5. [Import data from a CSV file — Atlassian Support](https://support.atlassian.com/jira-cloud-administration/docs/import-data-from-a-csv-file/)
6. [Link your object schema to a Jira project — Jira Service Management Data Center](https://confluence.atlassian.com/spaces/SERVICEDESKSERVER/pages/1044784360/6.+Link+your+object+schema+to+a+Jira+project)

Get a quote

## Moving from Jira to Asana?

Tell us roughly how many records and objects you have. We scope the mapping and the Asana setup with you, then send a quote.

[Get a quote](https://flitstack.ai/contact)
