Skip to content
Get a quote

Migrate to Jira

Jira is Atlassian's issue-tracking and project-management platform whose import model rewards teams that pre-create Issue Types, Workflow Schemes, Custom Field contexts and Project Roles before the first CSV is uploaded.

Short answer

FlitStack AI migrates projects, tasks, and timelines into Jira from 150+ project management tools, including Asana, Trello, Slack, Notion. Every field is mapped to Jira's objects, history and associations come across, the Jira setup is configured alongside, and the whole migration stays reversible in one click.

By

From Any source
DestinationJira
AsanaTrelloSlackNotionClickUp
150+ sources mapped into Jira

Systems we move into Jira

The project management tools teams most often move from. Each page shows what moves, the field mapping and what to watch for.

What Jira supports, and where its import tools stop

  • 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.
REST onlyOAuth 2.0 (3LO), API tokens, Forge, Connect
Rate limitsPoints-based rate limits with tiered quotas enforced per org; token-based traffic not affected by new points model
ObjectSupportNote
ProjectsfullProjects are the top-level container for all Jira work. They carry a project key (e.g., ENG, MKT), a type (business or software), and a default scheme for permissions and notifications. We migrate projects as-is and map the project key in the destination org. Schema is stable across Jira versions.
IssuesfullIssues are the primary record type in Jira. Standard fields include Summary, Description, Status, Priority, Assignee, Reporter, Labels, and Due Date. We preserve all standard fields 1:1. Custom field values are mapped individually.
Issue TypesfullJira ships with Issue Types: Task, Story, Bug, Epic (on Software plans), and sub-task variants. We map these directly and flag where the destination plan lacks a specific issue type (e.g., sub-tasks require a parent issue to exist first).
SubtasksmappedSubtasks are a distinct issue type that must be linked to a parent issue. The parent must exist in the destination before the subtask can be created. We sequence subtask creation after parent issue creation and validate the linkage in the target.
WorkflowsmappedWorkflows define Statuses and Transitions between them. Jira allows unlimited custom statuses and complex transition rules. We preserve workflow definitions but flag that unsupported validators (e.g., transition validators not supported by JCMA) are skipped during migration, which can alter permission enforcement on specific transitions.
Custom FieldsmappedJira supports an unlimited number of custom fields per project with no enforced global schema. Custom fields are stored per project context. We map each custom field by name and type, but we flag that some field types (e.g., cascading select, multi-user picker) may require reconfiguration in the destination or may lose pick-list metadata when migrated to a platform with a flat field model.
AttachmentsmappedAttachments are stored at the issue level. Jira Cloud imposes attachment size limits and the Jira Cloud Migration Assistant can migrate them, but oversized or corrupted files can cause import failures. We chunk large attachment batches and flag any file that exceeds the destination platform's size limit before attempting migration.
CommentsfullComments are stored as issue children with author, timestamp, and body. Jira Cloud natively exports comments to CSV. We preserve full comment text and metadata. Where the destination platform does not support threaded comments, we flatten into sequential comments and preserve the reply chain via timestamps.
WorklogsmappedWorklogs track time spent on issues. Jira Software includes built-in worklogging; Jira may require an add-on. We preserve worklog entries and map them to the destination's time-tracking schema, flagging whether the destination has native time-tracking or requires a plugin.
SprintsmappedSprints are time-boxed collections of issues in Jira Software. Jira does not have native sprint management — it is a project type distinction. When migrating from Jira Software to Jira, we convert active sprint assignments into labels or a custom field so the timing context is preserved even without a native Sprint object.
BoardsmappedBoards (Kanban and Scrum) are a visualization layer on top of Projects and Filters. They are not independent data objects — they reference a saved filter. We preserve the board configuration and the underlying filter JQL, but the board must be re-created in the destination if the Jira project key changes.
ComponentsfullComponents are optional groupings within a Project, used to assign default Assignees or Component Leads. We preserve Component names and assignments. Components do not carry their own issue data; they are a label on the issue.
VersionsfullVersions represent releases or milestones within a Project (e.g., v2.1, Q3 Sprint). Issues can be linked to zero or more Versions. We preserve Version names, release dates, and released/archived status.
LabelsfullLabels are free-text tags applied to Issues. Jira allows unlimited labels per issue. We migrate labels as-is. Labels are case-sensitive in Jira, so we preserve the exact casing as stored in the source.
Linked IssuesmappedJira supports multiple link types between issues (Blocks, Is Blocked by, Relates to, Duplicate, etc.). Linked issues must exist in the destination for the link to be functional. We migrate link types and target issue keys, but we flag any link where the target issue is not included in the migration scope as a dangling reference that must be resolved manually.
Users and GroupsmappedUser accounts, group memberships, and Project Role assignments are migrated via Jira's user management export. We map users to their destination accounts and flag where a user in the source has no match in the destination, requiring either account creation or reassignment before migration.

The Jira migration guide

Why teams migrate to Jira

The four shapes a Jira migration takes, and what makes the platform easier — or harder — than the category average.

Jira is a software product developed by Atlassian for bug tracking, issue tracking and agile project management1. Atlassian is headquartered in Sydney and San Francisco, with Jira available in three product lines on a single underlying engine: Jira Software (engineering and agile), Jira Service Management (ITSM and service desk) and Jira Work Management (business teams).

The typical Jira customer is a software-led organisation — anywhere from a 20-person startup to a 20,000-engineer enterprise — that wants configurable workflows, JQL-based reporting and a deep Marketplace ecosystem rather than the simpler, more opinionated trackers further down the category. Compared with monday.com or Asana, Jira positions on workflow depth and developer-tool integrations; compared with Azure DevOps it positions on platform neutrality and the strength of its app ecosystem.

The shapes of migration that actually land on Jira tend to fall into four patterns. First, PM consolidation: a company replacing Trello, Asana or ClickUp with Jira to standardise engineering and cross-functional work on one tracker. Second, DC-to-Cloud moves, where existing Jira Data Center customers migrate to Atlassian Cloud ahead of Data Center end-of-life on 28 March 202937.

Third, legacy issue-tracker replacements — Redmine, Trac, Bugzilla, MantisBT, or homegrown databases — where the source schema is loose and the project is really a re-architecture. Fourth, M&A integration, where an acquired business runs on a different tracker and the parent standardises on Jira. An Asana-to-Jira move usually has clean Project-to-Project parity but maps poorly across custom workflows; a Server-to-Cloud move retains schema but reshapes user identifiers and audit history.

What makes migrating to Jira easier than the category average is the official tooling — the Jira Cloud Migration Assistant (JCMA) for Data Center sources and a native CSV importer for everything else232. JCMA also generates a Post-Migration Reconciliation (PTR) Excel report that counts projects, issues, comments, attachments and boards source-vs-destination122.

What makes it harder than the average is the scheme model — Workflow Schemes, Field Configuration Schemes, Screen Schemes, Issue Type Schemes, Permission Schemes and Notification Schemes all map per-project per-issue-type25. Imports silently land issues against the wrong scheme set if the destination project's schemes are not pre-configured. Add the system-property override block — created, updated and creator cannot be overwritten on Cloud during standard CSV import — and the migration rewards careful pre-creation.

Workflows do not import via CSV — they are built in Settings → Issues → Workflows and applied through a Workflow Scheme before the first issue lands. Custom fields do not exist until created with the right type and context. Teams that scope for that work up front finish on time; teams that assume parity do not.

Workflows do not import. Custom fields do not exist until they are created. Teams that assume parity discover this on day two.

The Jira data model you need to map into

Projects, Issue Types, schemes and Custom Field contexts — the destination schema decoded, with the upsert keys you'll wire on every load.

Jira's data model is hierarchical: a Site contains Projects, each Project has Issue Types, each Issue Type is governed by a Workflow Scheme that defines its Statuses and Transitions. Issues belong to a Project, carry an Issue Key (PROJ-123), and are linked to other issues via Issue Links. Above the issue level, Epics group Stories/Tasks/Bugs, and Sub-tasks live one level below their parent.

Before you map a single field on the source side, you need to know which Project, which Issue Type, and which Workflow Scheme each row will land against. The table below summarises the objects you will touch in a Jira Software / Service Management / Work Management migration.

ObjectWhat it storesRequiredTier
ProjectsTop-level container — Software, Service Management, Work Management, Product DiscoveryName, Key (uppercase 2–10 chars), Lead, Project TypeAll editions
IssuesWork items — Story, Task, Bug, Epic, Sub-task and custom typesProject, Issue Type, Summary, ReporterAll editions
Sub-tasksChild issues belonging to a parentParent issue, Project, Issue Type, SummaryAll editions; requires Sub-task enabled on Issue Type Scheme
EpicsStory/Task aggregator — Jira Software hierarchy level 1Project, Epic Name, SummaryJira Software; Premium adds higher levels (Initiative)
ComponentsProject-scoped categorisation of issuesName, ProjectAll editions
Versions / Fix VersionsRelease containers — affected and fix-version dimensionsName, Project; optional Start/Release datesAll editions
SprintsTime-boxed work containers on Scrum boardsName, Board, Start date, End dateJira Software
BoardsScrum and Kanban work views backed by a FilterType (Scrum/Kanban), filter JQLJira Software
Workflows + StatusesState machines that govern Issue Type transitionsName, Statuses, Transitions; applied via Workflow SchemeAll editions
Custom FieldsUser-defined fields scoped via Field ContextsName, Type, Context (Project + Issue Type set)All editions; context model controls scope48
Assets / CMDB objectsConfiguration items linked to issues via the Assets custom fieldObject Schema, Object Type, AttributesJira Service Management Premium/Enterprise; 10M-object ceiling24

Issues use the Issue Key (e.g. PROJ-123) as their canonical identifier, but Jira also exposes a numeric Issue ID internally. For CSV updates of existing issues, the External System Import tool requires you to include the Issue Key in a column mapped to Issue Key so the importer upserts rather than creates121.

For first-time imports the upsert key you control is the legacy source ID — stamp it on each issue as a custom External ID or Legacy ID single-line text field. Build it on day one, populate from the source export, and use it for every subsequent delta.

Custom field types in Jira are based on a small set of primitive data types — string, number, user, group, datetime, option, option-with-children — each with documented JQL behaviour43. The catalogue below summarises the field-type estate you will model.

Field typeLimitNotes
Short text (single line)255 charsXML export bug truncates near 255-char strings with special chars87
Paragraph (multi-line text)32,767 charsAtlassian Document Format (ADF) on Cloud; Wiki Markup on DC
NumberIEEE 754 double-precision 64-bit floatSingle-select options are not summed; rebuild as Number field44
Date pickeryyyy-MM-dd via importFormat must match the Date format option chosen at import83
Date Time pickerISO-8601Imports default to dd/MMM/yy h:mm a; configurable
Select List (single choice)Up to thousands of options per contextOption must exist in the field context for the project84
Checkboxes / multi-selectMulti-value via repeated column headerComponent, Fix Version, Labels accept multiple cols of same header38
User pickerCloud uses Atlassian Account IDs; DC uses usernamesCross-environment migrations break user references113
Assets / CMDB objectUp to 10M objects per schemaRaised from 3M on 1 Nov 2025; requires JSM Premium24

Relationships in Jira are expressed three ways. First, issue hierarchy: Sub-task → parent issue → Epic → higher-level (Premium) — these are first-class parent/child relationships scoped to a Project. Second, Issue Links — configurable link types like blocks, is blocked by, relates to, duplicates, clones, used for cross-project dependencies and for non-hierarchical relationships54.

Third, Components, Fix Versions and Labels act as project-scoped tag dimensions, queryable via JQL. There is no native master-detail cascade-delete between Epics and Stories: deleting an Epic does not delete its Stories, which is a behaviour you may need to reproduce with an Automation rule if your source platform relied on it.

Custom Field contexts are the single most-misunderstood part of the Jira schema. A custom field with one name can have multiple contexts, each scoped to a different (Project, Issue Type) combination, each with its own option list and default value48. A row imported into the wrong project context will appear to drop its value even though the field name matches.

Pre-migration prep — the work before you touch Jira

What must be true on the source, the destination and across the team before the first row hits the importer or JCMA.

The single best predictor of a clean Jira migration is how much work you do on the source side before the first import button is pressed. Atlassian's own JCMA documentation pre-flights your data for over a dozen error classes and still warns that scheduled background jobs, large attachment estates and inactive users derail otherwise-healthy migrations7779.

The single best predictor of a clean Jira migration is how much work you do before you press Begin migration in JCMA.

Treat the source export as raw material that needs to be shaped to Jira's expected formats — dates rewritten to the chosen ISO format, users resolved to Atlassian Account IDs (Cloud) or usernames (Data Center), Issue Type and Status values mapped to the destination's existing names, and option-list values pre-created on the right Field Context.

Source-side prep

  • Audit and clean the source database before export. Atlassian's Clean up your instance before migration guide recommends deleting unused projects, schemes, custom fields and workflows so you migrate less rather than more7980.
  • Convert dates to the format you intend to declare on the importer's Date time format options step — Jira rejects rows with fields.validation.date.format when the file format does not match the declared format83.
  • Convert option lists so every value in single-select and multi-select columns exists as an option on the destination field's context — Jira returns custom field require options that do exist on any mismatch84.
  • Stamp a stable external ID on every record in the source export — the source platform's primary key — so re-runs and reconciliation are deterministic.
  • Decide what is in scope for historical comments, attachments and change history. CSV import preserves comments via the 01/01/2012 10:10;Admin; This comment works pattern and attachments via HTTP/HTTPS URLs in an Attachment column38.
  • Save the file as UTF-8 with BOM if you have non-ASCII characters — Jira warns when the file contains non-ASCII and the wrong encoding silently mojibakes German umlauts, French accents, CJK characters8291.

Destination-side prep

  • Create a sandbox on Jira Cloud Premium/Enterprise (or a development DC instance) and run the full migration end-to-end before touching production. Atlassian explicitly recommends a sandbox dry-run before any JCMA cutover124.
  • Provision users first through Okta, Microsoft Entra ID or another identity provider, then run the import — owner/reporter/assignee assignment fails silently if the referenced user does not exist or has no Jira product access113.
  • Pre-create every Custom Field with its Context on the right Project + Issue Type pair. Once a field is created, its type cannot be changed — you create a new field with the right type and migrate values across.
  • Build Workflows, Workflow Schemes, Issue Type Schemes, Field Configuration Schemes, Screen Schemes, Permission Schemes and Notification Schemes before importing any issues — issues land against the wrong scheme set if the destination project is not pre-configured.
  • Define Components and Fix Versions per Project before importing issues that reference them; the CSV importer accepts multiple column headers with the same name to import multi-value Component and Fix Version assignments38.

People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours — and communicate it widely. Stop all non-crucial scheduled jobs on the source Jira (re-indexing, archive, Tempo accruals); Atlassian flags scheduled jobs as a leading cause of degraded migration performance77. A small Jira-to-Jira move runs one to two business days; a Server-to-Cloud migration with 2,000+ users and ScriptRunner-heavy customisations runs four to twelve weeks even when JCMA completes overnight14.

Import mechanisms: JCMA, CSV importer, and Marketplace tools

Multiple paths in, each with different limits and shapes. Picking the wrong one is how mid-migrations stall at scale.

Jira exposes several load paths and the right one depends on the source platform, dataset size, and whether the migration is Jira-to-Jira or third-party-to-Jira. The Jira Cloud Migration Assistant (JCMA) is the official path for Data Center → Cloud. The CSV importer covers most one-shot loads from third-party trackers. Marketplace and ETL tools sit on top of all of these.

Jira Cloud Migration Assistant (JCMA)

JCMA is the Atlassian-built, free app installed on Jira Data Center that migrates Projects, Issues, Workflows, Schemes, Users, Boards and Filters to Jira Cloud36. It runs as a wizard: pre-migration checks → choose projects → select users and apps → assess → run. Atlassian's published best practice is to move groups of projects in business-impact-ordered waves rather than one big-bang cutover124.

JCMA generates a Post-migration Reconciliation (PTR) report as an Excel file that compares source-vs-destination entity counts for projects, issues, comments, attachments, boards, filters and configurations, so you can validate before users get access122. JCMA requires JCMA 1.12.45 or later for the PTR report.

CSV importer (External System Import)

Jira ships a native CSV importer at Settings (gear) → System → External System Import → CSV in both Cloud and Data Center3233. A newer Jira import experience moves data from Asana, Notion and other business-tool sources directly into Jira business and software spaces. The recommended number of work items per file is 1,500, with estimated time around an hour32.

The importer accepts CSV (and XLS/XLSX in the new experience). Each file needs a heading row with at minimum a Summary column; multi-value fields like Components, Fix Version and Labels are imported by repeating the column header38. Comments are loaded with the pattern MM/dd/yyyy HH:mm;username;comment-body; attachments via HTTP/HTTPS URLs in an Attachment column38157.

Marketplace and third-party staging tools

Exalate, Getint, OpsHub and Configuration Manager sit between the source and Jira. They handle two scenarios: (a) third-party-to-Jira where the source is ClickUp, Asana, Azure DevOps or Trello, and the tool handles field mapping plus attachments and comments, and (b) Jira-to-Jira with selective JQL-based migration and bidirectional sync during a transition window.

Mapping your data into Jira

The longest section — because for PM migrations, project hierarchy, Issue Links, time tracking, threaded comments and custom workflows are where almost every migration that fails actually breaks.

Mapping is where every Jira migration earns its scars. The schema decisions you make in your mapping spreadsheet determine whether boards work on day two, whether automations fire on day five, and whether your engineering team trusts the data on day thirty.

Work object by object, top to bottom of the import order: Projects + Schemes first (so issues have somewhere to land), then Users and Groups, then Components and Versions, then Epics, then Stories/Tasks/Bugs, then Sub-tasks, then Issue Links, then attachments and comments by CSV pattern.

Project hierarchy — Project → Epic → Story/Task/Bug → Sub-task

Jira's first-class hierarchy is Project → Epic → Story/Task/Bug → Sub-task, and Premium adds higher levels (Initiative, Theme) configurable in Settings → Issues → Issue type hierarchy. Sub-task and Epic are system Issue Types — their parent-child semantics are baked into the platform.

When importing, set the Parent column on a Sub-task row to the parent's external ID; set the Epic Link (legacy) or Parent column on a Story row to the Epic's external ID. The newer Jira import experience also lets you assign specific Issue Types — Epic, Task, Story, Bug, Subtask — during import, rather than defaulting everything to Task. Use this — defaulting to Task and changing types post-import breaks reporting until reconciled.

Common source → Jira Project / Issue mapping
SourceDestinationNote
project / workspace / spaceProject (with Key, Lead, Project Type)Pre-create on destination; Key is uppercase 2–10 chars
task / item / ticketIssue with Issue Type = Story/Task/BugMap Issue Type per row, not via global default
subtaskSub-task with Parent populatedParent column resolves to Issue Key during import
epic / initiative / goalEpic (or higher hierarchy on Premium)Epic Name and Summary both required for Epic rows
category / tag / areaComponent or LabelComponent is project-scoped; Label is global free-text
release / milestoneFix VersionPre-create the Version on the destination Project
due date / target dateDue dateFormat must match the importer's Date format option83
assigneeAssignee (Atlassian Account ID on Cloud)Cloud requires Account ID; DC uses username113
reporter / created byReporterFalls back to importer user if missing

Task dependencies — Issue Links, not hierarchy

Task dependencies in Jira are modelled through Issue Links with configurable Issue Link Types — defaults include blocks / is blocked by, relates to, duplicates, clones. Administrators can add custom link types via Settings → Issues → Issue linking54.

Issue Links can be populated via the CSV importer by adding columns named after each link type. Cross-project dependencies are supported natively — Issue Links span projects without restriction. The pragmatic approach for a source platform with a single dependency field is to import every dependency as a blocks link, then refine link types post-cutover.

Custom workflow status — Statuses and Workflow Schemes

Workflows are state machines built from Statuses and Transitions, applied to Issue Types via a Workflow Scheme on each Project. Every destination Status must be pre-created in Settings → Issues → Statuses before the workflow is built106.

When importing, the Status column value must exactly match the destination Status name, and that Status must be present on the workflow assigned to the Issue Type. Issues whose imported Status does not match the workflow's allowed states land on the workflow's initial status with the imported value dropped. Build the source-status → destination-Status mapping before the first dry run.

Time tracking — Original / Remaining / Logged

Jira has native time tracking with three fields: Original Estimate, Remaining Estimate and Logged Time (worklogs). Original and Remaining import via CSV columns in Jira's time-format (2w 1d 4h 30m). Worklogs import via repeated Log Work columns with the pattern time-spent;timestamp;author;comment.

For third-party trackers (Tempo, Harvest, Toggl), worklog migration is more involved. Atlassian's App Migration Platform coordinates with Tempo for Server-to-Cloud Tempo Timesheet migrations, but the support is partner-driven; projects without a Tempo migration path land worklogs as plain Jira worklogs, losing Tempo billing categories and account associations102.

Comments and attachments — threading and timestamps

Comments import with original timestamps via the CSV pattern 01/01/2012 10:10;Admin;This is a comment body in a Comment column — repeat the column header for multiple comments38. The author segment must match an Atlassian Account ID (Cloud) or username (DC); unresolved authors default to the importer user. Comments do not thread on Jira — they are flat and chronological on the Activity tab.

Attachments via CSV require HTTP/HTTPS URLs in an Attachment column, with optional timestamp and author: 01/01/2012 13:10;[email protected];image.png;file://image-name.png38. Attachment size on Cloud defaults to 1 GB per file (up to 2 GB configurable); Data Center caps at 10 MB per file153159. Plan storage caps: 2 GB per app on Free, 250 GB on Standard, unlimited on Premium153.

For migrations with hundreds of GB of attachments, keep originals in S3 or Google Drive, store a deep link in a custom URL field on the issue, and only inline-attach the most recent or most-referenced subset. This avoids both the per-file cap and the cumulative storage tier consumption.

Recurring tasks — Automation rules, not a property

Jira has no native recurring issue property. Recurrence is implemented via Automation rules in Project settings → Automation with a scheduled trigger (e.g. Every Monday at 9 AM, clone issue PROJ-123) or via Marketplace apps like Schedule for Jira. Source platforms (Asana, ClickUp, monday.com) that store a recurrence_rule on each task lose the rule structure on import; re-create as one Automation rule per distinct schedule.

For a migration with hundreds of distinct recurring rules, consolidate into 5-to-15 canonical Automations (daily standup, weekly review, monthly close, quarterly planning) and let team leads opt their issues in post-migration rather than mapping legacy recurrences one-to-one.

Custom-field mapping strategy

Resist the urge to map every source custom field one-to-one. Migrate only fields used by an active workflow, board, JQL filter or dashboard in the last 12 months. Atlassian's guidance is explicit: limit the number of custom fields in your import, avoid duplicating names of existing standard fields, and use generic names that can be reused48. Excess custom fields slow JQL and fragment context configurations.

For Select List fields whose source values do not match the destination, either (1) extend the destination field's context to include the missing options, (2) collapse adjacent values during transform, or (3) introduce a parallel custom field that holds the legacy value verbatim. Calculation / scripted fields do not import — they are rebuilt with ScriptRunner, Adaptavist Power Scripts or native Automation conditions post-load.

Audit trail, ownership and original timestamps

System fields created, updated, creator, reporter and the issue change history are partially preserved on import. The CSV importer accepts Date Created and Reporter columns; whether they round-trip correctly depends on the importer permission set113114. On Cloud, Modified Date cannot be set during a CSV import even by admins — Jira stamps the import time with no override114.

If you need to preserve the audit trail, create two custom datetime properties per issue type — Legacy Created Date and Legacy Modified Date — and populate them from the source export. Inactive source users are typically not recreated as Jira users (which would consume licences); instead, store name and email in a custom text field95.

Account-level audit logging is captured in Settings → System → Audit Log; Data Center exports up to 100,000 events as CSV and rotates daily logs at 100 MB each112. The Cloud audit log is admin-visible but limited to configuration-impact events — Jira's audit log is explicitly not intended to record all activity; it is a configuration-changes-only log118.

The pitfalls that derail Jira migrations

Specific failure modes — ranked by impact, each tied to the exact Jira mechanism that breaks.

Validation and cutover

What to verify after the import job, in what order — and how to fail safely when something is wrong.

Validation is the bridge between the import finishing and users being allowed in. Atlassian's JCMA Post-Migration Reconciliation (PTR) report is the canonical starting point for Data Center → Cloud — an Excel file generated automatically that counts projects, issues, comments, attachments, boards, filters and configurations source-vs-destination122. For third-party migrations the equivalent is a hand-built reconciliation spreadsheet, plus a manual spot-check protocol on real records.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance gets investigated before users get login access.

  • Total issues per project per Issue Type imported vs source — minus deliberately excluded rows (archived, deleted, out-of-scope).
  • Total issues per Status vs source — a non-trivial drift usually signals a status-mapping miss against the destination Workflow Scheme.
  • Total comments per project vs source, and a date-bucketed comparison to confirm comment timestamps round-tripped through the CSV MM/dd/yyyy HH:mm;author;body pattern.
  • Total attachments and total bytes per project — verify against tier storage cap (2 GB Free / 250 GB Standard / unlimited Premium)153.
  • Issue Links per link type — count blocks, is blocked by, relates to, duplicates and compare against source-derived expected counts54.
  • Worklogs per user and total time logged — SUM(timeSpentSeconds) GROUP BY author and compare to source-system totals.
  • Assignee and Reporter coverage — GROUP BY assignee and confirm no issue landed unassigned that had a source assignee (the silent Account ID resolution failure).
  • Sprint and Version assignments — count issues per Sprint, per Fix Version, and verify against source-platform release/sprint structure.

On top of reconciliation, run a manual spot-check protocol: pick 30 random issues across projects and verify each field against the source UI. Pick five high-value Epics and trace the full hierarchy — child Stories, Sub-tasks, Issue Links, attachments, comments, worklogs. If a non-trivial discrepancy shows up in three or more of the 30, halt the migration, fix the root cause, and re-import the affected rows by Issue Key.

Jira has no native bulk-undo. The closest mechanism is Bulk Change at Issues → Search → Tools → Bulk Change, which lets admins select issues by JQL and delete them in batches — deleting all imported issues is the only practical rollback path once a bad import lands122. Stamp every imported row with an Import Batch ID custom field so a single JQL query selects the entire batch for clean deletion.

The real rollback strategy remains: export everything to S3 before the import starts, snapshot the Jira database (DC) or rely on Cloud's daily backup, and if catastrophe strikes, bulk-delete by Import Batch ID and re-import. For JCMA DC-to-Cloud cutovers, keep DC live in read-only mode for 30 to 90 days post-Cloud-go-live as a fallback reference.

Cutover sequencing: (1) source goes read-only and teams are notified; (2) all non-crucial scheduled jobs are paused77; (3) final delta export captures everything that changed during the test-import window; (4) delta is imported; (5) PTR report or hand-built reconciliation runs; (6) users get login access and a 48-hour hyper-care window with the migration lead on call; (7) source decommission is scheduled for 30 to 90 days out, never the same day.

Migration partners and tools

Atlassian Solution Partners, Marketplace migration apps, ETL vendors — what each is good for and how to choose.

The Atlassian Partner Directory lists Platinum, Gold and Silver Solution Partners by certifications, customer count and product focus141. For Jira migrations, partners with explicit Server-to-Cloud, ClickUp-to-Jira or Asana-to-Jira practices ship cleaner than generalist shops; partners with Atlassian Cloud Specialization are the standard pick for JCMA-driven Data Center cutovers.

Common picks include Adaptavist, Isos Technology, Appfire, Modus Create, Praecipio Consulting and Eficode — each offers fixed-scope migration packages alongside ongoing managed services. Atlassian also offers cloud migration trial extensions: paid annual cloud subscriptions for 1,000+ user organisations qualify for up to one year free of overlapping DC subscription144.

Standard Marketplace picks include Exalate (bidirectional sync during cutover), Getint (Asana/ClickUp/Trello-to-Jira with attachments and comments) and OpsHub Migration Manager (enterprise Jira-to-Jira). For warehouse-resident sources, Fivetran, Airbyte, Stitch and Workato all ship Jira connectors used as the staging layer in ETL-fed migrations.

Managed-migration cost ranges vary widely. A clean Asana-to-Jira or Trello-to-Jira move of under 25,000 issues with standard Issue Types often lands in the $3,000–$10,000 range with a setup fee plus per-project pricing. A Jira Data Center to Cloud project with 2,000+ users, ScriptRunner customisations and 50+ Marketplace apps typically runs $40,000–$150,000+, with the upper end driven by user count, custom-field complexity and plugin migration paths rather than raw issue count142.

For teams that want to outsource the migration end-to-end, FlitStack specialises in Jira migrations and handles the Workflow Scheme construction, Custom Field Context configuration, Account ID resolution, historical-data preservation and reconciliation work described in Sections 5 and 7. Pricing is fixed-fee, based on issue count and source platform, with separate line items for Issue Link migration, worklog preservation and attachment volume.

This is one of several legitimate paths — the right choice for any given team depends on whether they want an Atlassian Solution Partner, a Marketplace-app-led migration, an ETL-staged approach, or a specialist migration vendor. [Explore FlitStack →](/contact)

Jira migration checklist

An exhaustive, phased punch list for moving an existing project workspace onto Atlassian Jira — from scoping through cutover to source decommission. Typical timeline: 6–16 weeks.

0. Decide & Plan12 tasks
  • Document the migration objective and the trigger event in one paragraph. Capture why the move is happening now (tool consolidation, Data Center end of support in 2029, M&A, Cloud-only feature need) so later scope debates resolve against the original intent.
  • Pick the destination Jira edition before any build work: Jira Software, Jira Service Management, Jira Work Management, or Jira Product Discovery. Editions differ on issue types, permission schemes, queue features and pricing. Mixing teams across editions changes the licensing and the import path.If skipped: Building under the wrong edition forces a re-architect once an edition-specific feature is needed mid-migration.
  • Pick the destination hosting model: Jira Cloud, Jira Data Center, or remain on legacy Server (end of support Feb 2024). Cloud uses JCMA (Jira Cloud Migration Assistant) for Data Center inbound and Site Import for cloud-to-cloud; Data Center is self-hosted with end-of-life scheduled for 2029.If skipped: Choosing Data Center now without a 2029 exit plan repeats the same migration in three years.
  • Define the in-scope object set: Projects, Issues, Issue Types, Issue Links, Sub-tasks, Comments, Attachments, Worklogs, Sprints, Boards, Filters, Dashboards, Users, Groups. List each object explicitly with an in-scope or out-of-scope flag. Treat dashboards, filters and automation rules as separate decisions from issues.If skipped: Implicit scope expands mid-project as stakeholders discover missing data, blowing the timeline.
  • Decide the historical-data window: how many years of source issues, comments and attachments come across. Pair each in-scope object with a date cut-off. Older issues can stay archived in the source export instead of imported.If skipped: Importing unbounded history inflates per-project issue counts and slows JQL queries permanently.
  • Choose the Jira Cloud plan tier (Free, Standard, Premium, Enterprise) before any build work. Audit log retention, sandbox, release tracks, advanced roadmaps, data residency and Atlassian Guard policies are gated by tier.If skipped: Building on Standard then discovering Premium-only sandbox or audit needs forces a mid-migration upgrade and re-test.
  • Select the hosting region for Jira Cloud: US, EU (Frankfurt), AP (Singapore, Sydney) or other available residency. Data residency is set per-product per-site and only available on Standard, Premium and Enterprise plans. Pin the region before any production data is created.If skipped: An EU customer left on the global tenant must move data residency later under regulator pressure.
  • Identify legal and compliance constraints that gate the cutover. Capture GDPR data-processing addenda, HIPAA BAA requirement (Atlassian Guard), SOC 2 evidence needs, ISO 27001 scope, customer contracts that name the source platform, retention policies that change on cutover.If skipped: A missing signed BAA on a HIPAA workload means PHI uploaded to Jira is non-compliant from day one.
  • Assign a single accountable migration owner (DRI) and a named delegate. One person signs off each phase. Cross-functional input is welcome; ownership is not shared.
  • Document explicit success criteria for cutover. Example: 100% of in-scope issues present, 99%+ comment fidelity, all attachments downloadable, Sprints reconstructed, dashboards rebuilt, sign-off by named users per team.If skipped: Without written criteria, every stakeholder applies their own bar and the project never formally closes.
  • Set the target cutover window (date + time + timezone) and the source-system freeze date. Pick a low-traffic window — weekend or quarter-end gap. Communicate the freeze date as the moment no new tickets can be created in the source.
  • Document out-of-scope items explicitly: legacy projects, archived dashboards, defunct integrations, dead automation rules, deprecated app data. Naming the un-migrated items pre-empts "why is this missing" questions in Phase 6.
1. Pre-Migration Prep28 tasks
  • Export source record counts per project, per issue type, per status as a numeric baseline. Capture counts per project, per status, per assignee. Save the export as the reconciliation reference for Phase 6 and the JCMA PTR (Pre-Migration Time Report / Post-Migration Reconciliation Report) comparison.If skipped: Without a baseline, post-cutover deltas can be explained away as normal instead of investigated.
  • Run dedup analysis on source issues using a stable match key. Match on source issue key or external ID where present, otherwise on (project, summary, reporter, created). Resolve duplicates in the source while you still have its dedup tooling.If skipped: Duplicates merged after import require manual cleanup against destination issue keys that did not exist at source time.
  • Normalize email casing and verify each user email resolves to a real mailbox. Lowercase all email addresses before export. Issues assigned to bounced mailboxes need assignee reassignment before cutover.
  • Standardize date and datetime values to ISO-8601 with explicit timezone. Jira stores dates in UTC and renders per-user timezone; mixed-format source dates surface as off-by-one-day errors on Due date, Start date and Sprint dates.If skipped: Date field imports silently shift days at the date-line, producing wrong deadlines on thousands of issues.
  • Audit and resolve issues missing values for fields that are required on the destination Field Configuration. Required fields block issue creation on import. The CSV importer aborts the issue with a validation error like "Original Estimate is required". Pre-fill or strip the requirement before load.If skipped: Import jobs surface validation errors mid-load, leaving the project in a half-populated state.
  • Audit source picklist / Select List / Radio Button options and rationalize them. Consolidate near-duplicate option values ("Won-Closed" vs "Closed Won") at source. Each Custom Field Context on Jira stores its own option set and accepts only exact matches.If skipped: Mismatched option values fail validation at import with messages like "custom field require options that do exist".
  • Re-encode any non-ASCII / non-UTF-8 source text as UTF-8 before export. Jira's CSV importer warns on non-ASCII characters and silently mis-renders mixed encodings; set UTF-8 across the export, the CSV file and Jira's encoding settings.If skipped: German, French and CJK characters arrive as garbled cells with no per-row error.
  • Strip or replace special characters in long text fields that exceed Jira's 255-character single-line field cap. Summary, single-line custom text fields and labels cap at 255 characters. Route over-length content to Description or a multi-line custom field.If skipped: Long titles truncate without warning, losing the back half of summaries on thousands of issues.
  • Clean up source apps, custom workflows and stale configurations before migration. Atlassian recommends pre-migration cleanup of unused workflows, schemes, custom fields and apps. JCMA scans the source and surfaces blockers; resolve them before running a real migration.If skipped: Carrying broken or unused configuration into Cloud pollutes the destination and inflates the time JCMA spends scanning.
  • Provision the production Jira site (xxxxx.atlassian.net) in the chosen region with the chosen edition and plan. Set data residency during provisioning where Premium/Enterprise allows. Default residency is global; pin to EU, US or AP per Phase 0.If skipped: An EU-resident customer left on the global tenant cannot pin data residency retroactively without admin intervention.
  • Provision a sandbox site (Premium/Enterprise) or a separate paid site for the dry run. Sandbox is included on Premium and Enterprise plans; otherwise create a separate paid Standard site as a dedicated sandbox. Never test in production.If skipped: Testing in the production site exposes incomplete data to end users before sign-off.
  • Configure site-level settings: default timezone, default language, working days, fiscal year, default user time format. These cascade into project defaults and affect how imported dates render.
  • Provision users with Atlassian Account IDs, not legacy email-based usernames. Cloud uses Atlassian Account IDs (accountId) for assignee, reporter and watcher fields; Data Center used usernames. Pre-create users via the admin UI or org-level user provisioning so import can resolve them.If skipped: Issues with assignees that do not resolve to a provisioned Account ID load with empty assignee and lose ownership.
  • Configure Atlassian Access / Atlassian Guard SSO with the corporate identity provider before any data lands. SAML SSO, user provisioning and two-step verification policies are configured per authentication policy. Enforce SSO before users get to the site.If skipped: Late SSO rollout means user passwords are set locally then re-set under SSO, doubling user friction.
  • Create every destination Project with the correct Project Type (Software, Service Management, Work Management, Product Discovery) and Project Template before any import. Project Type cannot be changed after creation. Team-managed vs Company-managed is also locked at create time and affects which schemes apply.If skipped: Creating a Team-managed project where Company-managed schemes are required forces project deletion and re-creation, breaking issue keys.
  • Create every required Issue Type per project and add them to the Issue Type Scheme. Standard types: Epic, Story, Task, Bug, Sub-task. Service Management adds Incident, Service Request, Problem, Change. Add any custom Issue Type before mapping.If skipped: Importing into a missing Issue Type defaults every row to Task and loses the source type semantically.
  • Create every Custom Field required by the mapping in Phase 3, including option lists for Select List / Radio Button / Multi-select fields. Custom Field options live on Custom Field Contexts; one context can scope a field to specific projects and issue types. Create the context before the import references it.If skipped: Importing a Select List value into a context without the matching option silently drops the value.
  • Configure Workflow Schemes per Project per Issue Type, mapping source workflow states to destination Statuses. Statuses must be created via the admin UI before workflows reference them. Workflows themselves can be built in the workflow editor or imported as Workflow XML.
  • Configure Field Configuration Schemes (required, hidden, screen visibility) per Project per Issue Type. Field Configurations control which fields are required, optional, or hidden on Create / Edit / View screens. Align them to the source schema so import doesn't trip required-field validation.If skipped: Required fields not pre-filled in the source export block every issue carrying that field empty.
  • Configure Screen Schemes and Issue Type Screen Schemes per Project so fields appear on the right screens. Screens decide what users see at Create, Edit, View. Screen Schemes bind screens to operations; Issue Type Screen Schemes bind a Screen Scheme to a project per issue type.
  • Configure Permission Schemes, Issue Security Schemes, Notification Schemes and Project Roles per project. Permission Schemes control who can do what; Issue Security restricts which issues a group/role can see; Project Roles avoid hard-coding individual users. Set these before users get access.If skipped: A wide-open Permission Scheme during migration exposes confidential issues to every licensed user.
  • Confirm any Marketplace apps required post-migration (Forge cloud-native or Connect legacy iframe) are installed and licensed in the destination. Apps are installed per site and licensed separately; JCMA migrates app data only for vendors that have integrated with the App Migration Platform.If skipped: Critical app data has no migration path and arrives as orphaned references with no UI hooks.
  • Pause all destination Automation rules and integrations during the load window. Automation rules fire on issue creation, status change and field update. A 50,000-issue load on a project with five active rules generates 250,000 rule executions.If skipped: Active automations notification-bomb every assignee with spurious assignment, status-change and SLA emails during load.
  • Confirm the destination site's attachment cap and storage allocation matches the migration volume. Free plans cap at 2 GB storage; Standard at 250 GB per product; Premium is unlimited. Per-file UI cap defaults to 1 GB on Cloud (max 2 GB).If skipped: Hitting the storage cap mid-load fails attachment uploads and leaves issues with broken file references.
  • Verify the Bulk Change permission is enabled for migration admins and the 1,000-issue-per-bulk-operation ceiling is acknowledged. The in-app Bulk Change tool applies edits to a maximum of 1,000 issues per operation. Plan multiple passes for larger projects.
  • Communicate the source-system freeze window to every active user with date, time and consequences. Email + Slack + source-system banner. Confirm receipt from project leads.
  • Identify and brief end-user trainers per team for go-live. Each team needs a designated trainer who knows JQL basics, board configuration and the new workflow.
  • Designate first responders to triage user issues for the first 48 hours after cutover. Rotation of two admins on-call during the post-cutover window.
2. Source Export14 tasks
  • Generate the JCMA Pre-Migration Time Report (PTR) on the Data Center source if migrating from Jira Data Center to Jira Cloud. PTR estimates the migration duration based on the source's data volume and surfaces blocking issues. Run it at least once well before cutover.If skipped: Without PTR, the cutover window is sized by guess and overruns the freeze window.
  • Export each in-scope Project as CSV/XLSX with every standard and custom field selected. Native Jira CSV importer recommends 1,500 issues per file with an estimated ~1 hour per import. Split projects exceeding that into multiple files.If skipped: A 50,000-issue dump in one CSV stalls the importer and times out before completion.
  • Export the user list with Atlassian Account IDs (Cloud source) or usernames (DC source), email, display name, active flag and group memberships. User format differs between Cloud (accountId) and Data Center (username). Capture both where the source is DC and the destination is Cloud.If skipped: Importing assignees by username into Cloud silently leaves the field unassigned because Cloud expects accountId.
  • Export Issue Links as a separate file with source key, target key, link type (blocks, is blocked by, relates to, duplicates, clones, is cloned by, etc.). Issue Links are the cross-issue relationship layer. Native CSV import accepts a Link column referencing destination keys after issues are loaded.
  • Export Sub-task parent / child relationships and Epic-link associations. Sub-tasks reference their parent's issue key; Stories reference their Epic. Both link types must survive the move.If skipped: Lost Epic-link associations break every backlog and roadmap view that filters by epic.
  • Export Comments per issue as a separate file or as bundled columns on the issue export. CSV format: one Comment column per comment instance, formatted timestamp;author;body. Preserve order. The new import experience supports comment migration directly.
  • Export Worklogs per issue as a separate file with timestamp, author, time-spent, work-description. Worklogs are Jira's native time-tracking entries (Original Estimate / Remaining Estimate / Time Logged). They have a distinct schema from comments.
  • Export attachments — both the file binaries and the issue-to-attachment mapping. Download every attachment to local disk, keyed by source issue key + filename. The CSV importer references attachments by URL or by file path on the same host.If skipped: Skipping the binaries leaves the destination with attachment metadata pointing at URLs that go dark once the source is decommissioned.
  • Export every Sprint with name, goal, start date, end date, complete date and associated board. Sprints are part of Jira Software; they live on Scrum boards and have their own object model.
  • Export every Board configuration: filter JQL, columns, swimlanes, quick filters, working days, estimation field. Boards are rebuilt at the destination from the filter and column config. Capture as screenshots plus the JQL string.
  • Export every Filter (saved JQL) and Dashboard configuration. Filters and Dashboards do not transfer through CSV import; capture the JQL strings and gadget configurations to rebuild post-cutover.
  • Export Workflow definitions as Workflow XML where the source supports it. Workflow XML carries statuses, transitions, conditions, validators and post-functions. Import into the destination's workflow editor where compatible.
  • Capture screenshots and JSON exports of every Automation rule on the source. Automation rules do not auto-migrate across sites; they are rebuilt manually. Recurring-task patterns also live in Automation since Jira has no native recurrence property.
  • Document the exact UTC timestamp of every export. This is the baseline against which the cutover delta is measured. Stamp the timestamp on the filename.If skipped: Without an export timestamp, you cannot compute what changed between export and cutover.
3. Transform & Map29 tasks
  • Build a master mapping spreadsheet: one row per source field with destination field, custom field ID (customfield_XXXXX), type, transform and required-on-import flag. Include nullability, default value, the Custom Field Context that scopes it, and whether the field is on the Create / Edit / View screen.If skipped: Without a single mapping artefact, transformation rules drift between engineers and the same source field maps two different ways.
  • Resolve every source field with no destination equivalent: drop, concatenate into Description, or create a new Custom Field. Document the decision in the mapping spreadsheet. Concatenated fields keep history without inflating the custom-field count.
  • Decide the upsert key per object and document it. Typical: source system issue key stored in a single-line text Custom Field on Jira. External System Import can update issues that match this key on re-runs.If skipped: Without a stable upsert key, partial re-imports duplicate every previously loaded issue.
  • Resolve Status value mismatches against the destination Workflow's Status set. Map source ("In Review", "Under Review", "Reviewing") to one destination Status. Create any missing Status via the admin UI before load.If skipped: An unmapped source status fails workflow validation and blocks the issue from being created.
  • Resolve Select List / Radio Button option mismatches per Custom Field Context. Each option must exist on the field's context. The CSV importer surfaces "custom field require options that do exist" when a value is missing.
  • Decide the assignee strategy: best-match by email to Account ID, or assign to a single migration service user. Jira Cloud requires Account ID for the assignee, reporter and watcher fields. Issues whose assignee emails do not resolve to a provisioned Account ID load with empty assignee.If skipped: Storing the inactive original assignee in a custom text field preserves history without inflating the licensed user count.
  • Decide the historical-timestamp strategy. Jira's CSV importer does not allow overriding system Modified Date on import; Created Date can be set via the Date Created column. Capture original modified-date in a custom Date field where preservation matters.If skipped: If historical SLA reports depend on modified-date, losing it misrepresents past performance permanently.
  • Decide the Issue Type mapping per source type. Jira's new import experience (2025+) supports mapping each source type to a specific destination Issue Type (Epic, Story, Task, Bug, Sub-task) at import time. Earlier importers defaulted everything to Task.If skipped: Defaulting every source type to Task loses the type semantically and breaks every report grouped by Issue Type.
  • Convert date and datetime fields to the format selected in the import wizard's Date Time Format Options. The wizard accepts a configurable date pattern; pick one and convert all source values to it. Mismatched formats throw fields.validation.date.format errors.If skipped: A single off-format date row fails the entire issue import with a date-validation error.
  • Normalize multi-value fields (Fix Version, Component, Labels) into the CSV importer's repeated-column convention. To import multiple values, repeat the column name for each value. The number of repeated columns must match the maximum number of values per row.If skipped: Comma-separated values inside a single Labels cell load as one giant label, not as separate labels.
  • Truncate or re-route text fields that exceed Jira's 255-character single-line cap. Summary and most single-line text fields cap at 255 characters. Route over-length content to Description (multi-line) or a Long Text custom field.
  • Re-encode every CSV file as UTF-8 with no BOM unless the importer requires it. Atlassian recommends UTF-8 across Jira, the file and the import settings. Mixed encoding silently mis-renders non-ASCII characters.If skipped: German umlauts, French accents and CJK characters arrive as garbled cells with no row-level error.
  • Escape commas, newlines and double-quote characters in CSV cells per RFC 4180. Wrap any cell containing a comma, newline or quote in double quotes and double-escape internal quotes. The CSV header row should contain no punctuation other than the separating commas.If skipped: An unescaped newline in a Description cell breaks every subsequent row's column alignment.
  • Normalize the Date Created column to the importer's expected date format if preserving original creation timestamps. Mapping the Date Created column on import preserves source creation time. Without this column, the importer stamps create-time to the import moment.
  • Normalize Original Estimate, Remaining Estimate and Time Spent values to Jira's duration format (e.g. 1w 2d 3h 30m). Jira Worklog and Estimate fields parse a strict subset of duration strings. Source decimal hours (1.5h) must convert to the supported format (1h 30m).
  • Implement the chosen assignee strategy across the transformed files. Either resolve every source assignee email to an Atlassian Account ID, or hard-write the migration service Account ID everywhere.
  • Stamp original source issue keys into a dedicated single-line text Custom Field on every issue. Field name like source_system_key makes later cross-system reporting and audit-log tracing possible.If skipped: Without a back-reference, debugging why an issue ended up where it did requires a manual hunt through the source export.
  • Stamp original created_at and modified_at into dedicated Date custom fields alongside the system timestamps. These power the audit-trail validation in Phase 6.
  • Decide the attachment strategy: re-upload binaries to Jira vs. link out to external storage (Google Drive, OneDrive, Dropbox, Box). Cloud per-file UI cap defaults to 1 GB (max 2 GB). Account storage is plan-capped (2 GB Free / 250 GB Standard / unlimited Premium).If skipped: Re-uploading every binary can exhaust the storage cap and silently fail later uploads.
  • Acknowledge that the Activity tab audit history is not portable across sites. Comments and worklogs migrate; the field-change Activity history does not transfer through CSV import or JCMA in full fidelity. Capture critical field-change history in a custom Long Text field if it matters.
  • Map the source project hierarchy onto Jira's Site → Project → Epic → Story / Task / Bug → Sub-task structure. A common pattern: source portfolio → Site (or multiple Projects); source program → Epic; source project → Story or Task; source sub-task → Sub-task. Jira's parent-child link is Epic-Link for Story-to-Epic and the Sub-task type for Sub-task-to-parent.If skipped: Flattening five source levels onto Jira's four-level model without an explicit rule produces unpredictable parent-child links and broken roadmaps.
  • Translate source task dependencies into Issue Links with the right link type (blocks, is blocked by, relates to, duplicates, clones, is cloned by). Issue Links are configurable per site. Create any custom link type before load. Native CSV import accepts a Link column referencing destination keys after the issues themselves exist.If skipped: Dependency pairs imported before both linked issues exist silently drop the link.
  • Translate source time entries into native Jira Worklogs with Original Estimate, Remaining Estimate and Time Logged values. Each worklog needs author Account ID, started timestamp, time-spent and an optional comment. Native time tracking lives at the issue level under the Time Tracking section.If skipped: Worklogs lacking author Account IDs default to the import user and misattribute thousands of hours.
  • Reconstruct comments threading via the Activity tab payload with @-mentions and visibility restrictions intact. Comments support @-mentions referencing Account IDs and visibility restrictions to a Project Role or Group. Preserve both in the transform; @-mentions to unresolved users render as plain text.If skipped: Visibility-restricted comments that lose their restriction become world-readable to every project member.
  • Plan custom workflow Status mappings per Issue Type per Project, attached via Workflow Schemes. Workflows are bound to projects via Workflow Schemes per Issue Type. Statuses must be created via the admin UI first, then referenced by the workflow.If skipped: Skipping Status creation up front fails the workflow transition the moment the first issue of that type hits it.
  • Re-create source recurring-task rules as Jira Automation rules in the destination. Jira has no native recurring-issue property. Recurrence is built with Automation rules using the Scheduled trigger and Create Issue action; document each source recurrence and queue the rule for activation post-cutover.
  • Plan the attachment migration path: JCMA cloud-to-cloud (DC → Cloud) handles binaries natively; CSV import references attachments by URL or file path. Choose the path that fits the median file size and total volume.If skipped: Mixing paths on the same project leaves attachments scattered between native files and external links with no single source of truth.
  • Plan Sprint reconstruction: each Sprint name, goal, start, end and complete date is rebuilt on the destination Scrum board. Sprints are board-bound. Closed Sprints carry historical velocity; recreate them with the original dates on the destination before re-assigning issues to them via the Sprint custom field.If skipped: Reassigning issues to a freshly created Sprint with today's dates inflates current-sprint velocity and erases historical velocity charts.
  • Plan Board, Filter and Dashboard rebuild post-cutover. Boards, Filters and Dashboards do not transfer through CSV import. Rebuild each board's JQL filter, column config, swimlanes and quick filters; rebuild each dashboard's gadget set against the new filters.
4. Sandbox Test Migration13 tasks
  • Load a representative 1–5% sample of issues per project into the sandbox using the chosen import method. Mix issue types, statuses, custom-field-heavy issues, issues with comments, issues with worklogs and issues with attachments. The sample must exercise every transform path.If skipped: Sampling only happy-path issues hides the edge cases that fail production at high volume.
  • Validate field-by-field on 5–10 random sandbox issues that values arrived correctly. Walk the source issue and the destination issue side by side; check Summary, Description, Status, Assignee, Reporter, Priority, every Custom Field, Comments order and Worklog totals.
  • Test the edge cases: 255-character summaries, non-UTF-8 characters, NULL custom fields, multi-value Labels, multi-value Components, multi-value Fix Versions. Each edge case is a known importer failure mode. Validate the transform handles every one without manual touch.
  • Test datetime timezone handling explicitly on Created, Updated, Due Date, Start Date and Sprint dates. Cross-check a sample of dates between source and destination across a date-line boundary.If skipped: Timezone bugs surface as one-day-off due dates only when the user is in a non-UTC timezone — easy to miss in QA.
  • Test Issue Link import order: load both linked issues first, then load Issue Links referencing destination keys. Both issues at either end of the link must exist before the link is created.If skipped: Link rows referencing not-yet-created issues silently drop and leave dependencies missing.
  • Test Sub-task / Epic-Link import order: load parent issues first, then load children referencing parent keys. Sub-tasks reference parent issue keys; Stories reference Epic keys. The hierarchy must load bottom-up by parent depth.
  • Test Sprint reconstruction: create the historical Sprints on the destination board, then write the Sprint custom field on each issue. Verify closed Sprints render in historical velocity charts with the original dates, not today's.If skipped: Sprints recreated with today's dates erase the project's velocity history irreversibly.
  • Test attachment migration: re-upload binaries, validate they download intact and the issue thumbnail renders. Open 20 random issues, click each attachment, verify the file opens with the right content type and the right binary.
  • Time the test runs and extrapolate to production volume. Native CSV importer's published guidance is ~1 hour per 1,500 issues. JCMA throughput depends on the source size and the PTR estimate. Confirm the production load fits the freeze window.
  • Run a Bulk Change pass on the sandbox to confirm permissions, the 1,000-issue ceiling, and the chosen Bulk Change operations work. If the migration plan includes a post-load Bulk Change (e.g. label normalization, assignee re-assignment), exercise it now.
  • Have a domain expert from each using team validate 20 sandbox issues for correctness. Engineering lead, PM, support manager. They will see semantic errors a migration engineer cannot.
  • Document every sandbox issue, root cause and fix in a defect log. Track issues to closure; the defect log is the input to the cutover go/no-go decision.
  • Get written sandbox-test sign-off from the migration sponsor before scheduling production cutover. No sign-off, no cutover. The sandbox is the trust-building artefact.If skipped: Skipping sandbox sign-off means surprises in production where rollback is expensive and visible.
5. Production Cutover12 tasks
  • Confirm the source-system freeze is in place: no new issue creation, no edits in the last hour. Verify via source admin UI and via a source-side audit-log query.If skipped: Writes after the export baseline produce a permanent delta between source and destination.
  • Take a final delta export of any source changes since the Phase 2 baseline. Filter by updated > baseline_timestamp. This is the rows that will be loaded as the cutover delta.
  • Disable every Automation rule and integration on the destination site. Rules fire on issue create, status change and field update. With them active, a 50,000-issue load can fire 250,000+ rule executions and notification bursts.If skipped: Live automations during load notification-bomb every assignee with spurious assignment and status-change emails.
  • Load users and groups first. Assignee, reporter, watcher and worklog-author Account IDs must resolve. Users created mid-load are a common race-condition source.
  • Load projects, then create Epics, then load Stories / Tasks / Bugs referencing those Epics by key, then load Sub-tasks referencing parent keys. Hierarchy is loaded top-down: parent must exist before child. Native CSV accepts an Epic Link column and a Parent column.If skipped: Children loaded before parents either fail validation or load with empty parent references.
  • Load Issue Links last (or in a second pass) once both linked issues exist. Use the Link column on CSV. Both linked issues must already exist.
  • Use idempotent upserts keyed off the stored source issue key wherever the chosen mechanism supports it. External System Import via CSV can update existing issues matched on Issue ID. Re-runs should not duplicate.If skipped: Non-idempotent re-runs after a partial failure duplicate every successfully loaded issue.
  • Load Comments and Worklogs against the loaded issues in a second pass. Preserve author Account ID and timestamps on every record.
  • Load attachments via the chosen path (JCMA cloud-to-cloud or external links). Capture upload job IDs and per-file success/failure to a log so failed binaries can be retried.
  • Capture import job IDs, row counts and error logs for every load step. These are the inputs to Phase 6 reconciliation. Without them, validation is guesswork.
  • Cross-check destination issue count against source baseline after each load step. If counts diverge, stop, diagnose and fix the transform before proceeding.If skipped: Pushing through with partial data hides the gap and surfaces it as user complaints two weeks later.
  • Re-enable Automation rules and integrations in waves after Phase 6 validation has started, not before. Phase 6 validation must run with a quiet destination so reconciliation is not polluted by automation-generated activity.
6. Validate21 tasks
  • Run the JCMA Post-Migration Reconciliation (PTR) report if migrating from Jira Data Center to Jira Cloud via JCMA. JCMA 1.12.45+ generates an Excel PTR comparing source and destination entity counts (projects, issues, comments, attachments, boards, filters, configurations). Investigate every delta.If skipped: Without PTR, count deltas surface as user complaints weeks later instead of as a structured report on day one.
  • Compare total issue count per project: source vs. destination. Investigate any delta. Use JQL on the destination: project = X AND created < cutover_timestamp. Compare to the Phase 1 baseline.
  • Compare open issue count per project (status != Done) source vs. destination. The PM-category aggregate analogous to pipeline value: how many active issues survived the migration intact.
  • Compare comment count per issue on a 25-issue random sample. Comment-thread reassembly is one of the most common migration losses.If skipped: Lost comments are invisible until a user looks for a specific decision and cannot find it.
  • Compare worklog total hours per project source vs. destination. Worklog hours drive billing and capacity reports. A 1% delta on hours becomes a 1% delta on revenue or capacity calculations.If skipped: Worklog drift goes undetected until the finance team reconciles month-end and finds the hours don't match.
  • Cross-check 25–50 randomly selected issues field-by-field between source and destination. Walk every visible field: Summary, Description, Status, Assignee, Reporter, Priority, every Custom Field, Labels, Components, Fix Versions, Affects Versions, Due Date, Start Date.
  • Verify every Custom Field's value arrived intact on a 25-issue sample. Spot-check Select List options, Date values, User-picker resolution and Number formats.
  • Verify Epic-Link relationships on a sample of Stories: open the Epic, confirm the Story appears under it. Roadmap and backlog views depend on Epic-Link.If skipped: Lost Epic-Links break every Roadmap and Advanced Roadmap view that filters by Epic.
  • Verify Sub-task parent links on a sample of Sub-tasks. Sub-tasks open inside their parent issue. A broken parent reference orphans the sub-task.
  • Verify Issue Links (blocks / is blocked by / relates to / duplicates) on a sample. Walk both directions: from blocker to blocked and from blocked to blocker.
  • Verify Sprint reconstruction: closed Sprints show with their original start/end/complete dates and their original issue membership. Render the historical velocity chart and confirm it matches the source's velocity chart.If skipped: Sprints reconstructed with today's dates render a flat historical velocity, erasing the team's actual history.
  • Verify attachments are accessible and linked to the right issues. Open 25 random issues with attachments; download each file; confirm the binary matches the source binary by hash or visual inspection.
  • Verify Comments preserve order, @-mentions resolve to the right users, and visibility restrictions hold. Visibility-restricted comments must still be restricted to the original Project Role or Group.If skipped: A visibility-restricted comment that lost its restriction becomes world-readable to every project member.
  • Verify the audit-trail strategy worked: original Created Date renders correctly on a sample. If Created Date was preserved via the Date Created column on import, confirm it on 25 random issues.
  • Verify original assignee and reporter history is preserved (in custom fields or in the live fields) per the Phase 3 decision. Reassigning to a single migration service user is fine; losing the original assignee history without preservation in a custom field is not.
  • Confirm Jira Cloud data residency: in-scope app data is hosted in the chosen region (US, EU, AP). Verify in the Atlassian Administration → Data residency settings. Data residency applies to Jira, Jira Service Management, Jira Product Discovery and Confluence on Premium / Enterprise plans.If skipped: An EU-resident customer whose Jira data is on the global tenant is non-compliant with GDPR data-residency commitments.
  • Confirm the audit log on the destination captures configuration events at the expected granularity for the tier. Free plans do not include the audit log. Standard/Premium/Enterprise capture configuration changes; Enterprise plus Atlassian Guard extend organization-level activity capture.
  • Confirm SOC 2, ISO 27001, HIPAA evidence collection is in place if regulated. Atlassian's compliance reports cover the platform; the customer is responsible for the in-tenant configuration evidence. Capture screenshots of SSO, MFA, audit settings and BAA.
  • Have 3–5 power users per team validate that their day-to-day workflows work in the destination with migrated data. Engineer creates a Story, triages a Bug, logs a worklog, transitions through the workflow. Support agent opens a Service Request, replies, escalates, resolves.
  • Document every data issue surfaced by UAT and triage it to closure before opening the site to general users. UAT defects are usually transform bugs, not data bugs. Fix in the transform and re-run for affected issues only.
  • Get written sign-off from the migration sponsor before proceeding to Phase 7. Sign-off lists: reconciliation pass, relationship pass, audit pass, UAT pass. Sponsor name + date.If skipped: Skipping written sign-off leaves the project open-ended and lets every post-cutover edge case re-open the migration.
7. Post-Migration Cleanup13 tasks
  • Send the go-live announcement to every end user with login URL, SSO instructions and a where-to-get-help contact. Email + Slack + intranet banner. Include the source decommission date so users do not return to the old system.
  • Run role-segmented training sessions on Jira basics: JQL, issue creation, board navigation, sprint planning, worklog entry, Bulk Change. One session per persona: engineer, PM, manager, executive. Record each session for asynchronous viewers.
  • Set the source system to read-only and announce the read-only date. Disable issue creation, comment, edit and workflow transitions on the source. Read-only is the bridge between cutover and decommission.
  • Rebuild every Filter (saved JQL) in the destination and share with the original audiences. Filters do not transfer through CSV import. Use the captured JQL strings from Phase 2.
  • Rebuild every Board (Scrum and Kanban) in the destination with the original filter, columns, swimlanes and quick filters. Boards are bound to a filter; create the filter first, then the board.
  • Rebuild every Dashboard with its original gadgets and shared audience. Dashboards do not transfer; rebuild each gadget against the rebuilt filters.
  • Rebuild every Automation rule from the captured source rule documentation. Automation rules do not auto-migrate. Recurring-task patterns must also be rebuilt as scheduled Automation rules since Jira has no native recurrence.If skipped: Forgotten automation rules surface weeks later as missed SLA, missed status transitions and missed notifications.
  • Re-enable integrations to other systems (calendar sync, code repo, BI tools, identity provider). Re-enable in waves and confirm each integration test-fires correctly before opening to all users.
  • Configure ongoing user provisioning through Atlassian Guard or SAML JIT. Without provisioning, leavers retain access until manually removed.If skipped: Leavers retaining Jira access exposes confidential project data to insider-risk between offboarding and manual removal.
  • Schedule a 30-day retrospective with the migration team and an executive sponsor. Capture what went well, what did not, and what would change for the next migration.
  • Decide and document the source system's decommission date. Common pattern: 90 days after cutover, after the final retention window passes. Communicate to every user.
  • Archive every source export, the migration log and the JCMA PTR report to long-term storage. Encrypted cold storage in S3, Azure Blob or equivalent. Tag with the cutover date and the retention period.If skipped: Discarded source exports remove the only forensic record if a post-cutover dispute arises a year later.
  • Close the migration project formally: final status report, lessons-learned doc, project closure email. A formal close prevents the project re-opening every time someone finds an edge case post-cutover.

Questions, answered

Migrating to Jira: questions

How long does migration to Jira take?

A small Trello-to-Jira or Asana-to-Jira migration with under 5,000 issues and standard Issue Types runs one to two business days end-to-end. A Jira Data Center to Cloud project with 2,000+ users, custom workflows and Marketplace apps runs four to twelve weeks of elapsed time, including JCMA dry runs, validation, training and hyper-care.

Can I migrate from Jira Data Center to Jira Cloud?

Yes — the Jira Cloud Migration Assistant (JCMA) is the official, free Atlassian-built tool for Data Center to Cloud. It migrates Projects, Issues, Workflows, Schemes, Users, Boards and Filters in batches and generates a Post-Migration Reconciliation Excel report for validation. Data Center end-of-life is 28 March 2029.

Can I migrate from Asana, ClickUp, or Trello to Jira?

Yes. The newer Jira import experience supports direct import from Asana and Notion, and the standard CSV importer plus Marketplace tools like Exalate and Getint handle ClickUp, Trello and other third-party trackers. Watch Issue Type mapping, custom field context creation, and Atlassian Account ID resolution for assignees.

Does Jira preserve original timestamps and audit trail on import?

Partially. Comment timestamps and worklog timestamps can be set via the CSV `MM/dd/yyyy HH:mm;author;body` pattern. But on Cloud, Modified Date cannot be overridden during CSV import even by admins, and JCMA preserves more history than CSV. Use custom Legacy Created Date fields for full preservation.

What's the difference between using JCMA and the CSV importer for Jira?

JCMA is the official tool for Jira Data Center to Cloud — Atlassian-built, free, batch-capable. The CSV importer handles third-party sources up to ~1,500 issues per file in the recommended sweet spot. For larger or more complex moves, Marketplace migration apps like Exalate, Getint and OpsHub fill the gap.

Can I migrate custom workflows and Statuses to Jira?

Workflows do not import via CSV — they are built in Settings → Issues → Workflows and applied through a Workflow Scheme before issues land. Every destination Status must be pre-created in Settings → Issues → Statuses before the workflow is built. Plan the workflow mapping early.

What happens to time tracking and worklogs during migration?

Original Estimate and Remaining Estimate import via CSV columns in Jira's time format (2w 1d 4h 30m). Worklogs import via repeated Log Work columns, with author resolution to Atlassian Account ID. Tempo Timesheet history requires a partner-driven migration path; plain Jira worklogs migrate without Tempo-specific billing data.

Is there an undo or rollback for Jira imports?

There is no native bulk-undo. The standard practice is to stamp every imported issue with an Import Batch ID custom field, then use Bulk Change (Issues → Search → Tools → Bulk Change) to delete by JQL on that field. Cloud relies on daily backups; Data Center on database snapshots.

Sources

  1. Jira (software) — Wikipedia
  2. Import data from a CSV file — Atlassian Support
  3. Jira Service Management on-prem alternatives after Atlassian's 2029 deadline — r/atlassian
  4. Atlassian pricing & product changes to Jira, Trello, on-prem explained — r/Superthread_
  5. Looking for On-Prem Alternatives to Jira/Confluence in a Highly Regulated Financial Environment — r/jira
  6. Atlassian raising Jira/Confluence Data Center prices again while EOL is set for 2029 — r/XWiki
  7. Migrate from Atlassian to ONES.com: DC timeline — Feb 17 2026 pricing, Mar 30 2026 end of sale, Mar 28 2029 EOL — r/ones_dot_com
  8. You can now store up to 10 Million Objects in Assets! — Atlassian Community
  9. Link your object schema to a Jira project — Jira Service Management Data Center
  10. Import data from a CSV file — Atlassian Support (limits & timing)
  11. Importing data from CSV — Administering Jira applications Data Center
  12. Step-by-Step Guide: Migrating Jira Data Center to Jira Cloud Using the Migration Assistant
  13. Create work items using the CSV importer — Jira Cloud
  14. Custom field types in Jira — Atlassian Community
  15. Custom fields — select options not recognized as numbers — Atlassian Community
  16. Map CSV data to Jira fields — Jira Cloud Support
  17. How to create parent/child relationships between stories or tasks — Atlassian Community
  18. Jira Cloud Migration Assistant pre-migration checklist — Atlassian Support
  19. Clean up your instance before migration — Atlassian Support
  20. Clean up your Server instance before migration — Atlassian Support
  21. How do I resolve encoding errors during an import — Atlassian Community
  22. Jira import date format error — Atlassian Community
  23. Import validation error — custom field require options that do exist — Atlassian Community
  24. XML Exports containing special characters (Ellipsis) — 255-char truncation — jira.atlassian.com
  25. Unable to import required fields into JIRA — Atlassian Community
  26. Which file encoding should I use for importing CSV with German characters — Atlassian Community
  27. Mastering Jira Migration Guide: Part 1 — Atlassian Community
  28. Support migration of Tempo Timesheets-Time Tracking & Reports — jira.atlassian.com
  29. Pre-create Statuses for workflow build — Atlassian Community
  30. Auditing in Jira — Administering Jira applications Data Center
  31. Finding user names to bulk upload issues via CSV — Atlassian Community
  32. Unable to set Modified Date while importing issues from CSV — Atlassian Community
  33. Audit activities in Jira — Atlassian Support
  34. CSV Bulk Update Existing issues — Atlassian Community
  35. Understanding the Post-Migration Reconciliation (PTR) Report in JCMA — Atlassian
  36. The Jira Data Center Migration Blueprint: 10 Best Practices — Atlassian Community
  37. Atlassian Partner Directory
  38. Cost to stand up JIRA Help Desk in the cloud $80k — r/sysadmin
  39. Cloud transformation costs — Atlassian
  40. Configure file attachments — Atlassian Support
  41. How to migrate issues with attachments using the CSV import in Jira Server and Data Center — Atlassian
  42. Attachment size limit in Jira Cloud — Atlassian Community

Get a quote

Moving to Jira?

Tell us where your data lives today and roughly how much there is. We scope the migration and the Jira setup with you, then send a quote.

Get a quote