Project Management migration
Field-level mapping, validation, and rollback between Backlog and Jira. We move data and schema; workflows are rebuilt natively in Jira.
Backlog
Source
Jira
Destination
Compatibility
11 of 12
objects map 1:1 between Backlog and Jira.
Complexity
BStandard
Timeline
2-4 weeks
Overview
Moving from Backlog to Jira is primarily an issue-tracking and hierarchy migration with three structural shifts to resolve. First, Backlog's parent-child Subtask model maps to Jira's dedicated Subtask issue type within an issue type scheme — we create the scheme and configure the link type during schema design so subtasks land correctly. Second, Backlog's Custom Fields (available only on Premium and Enterprise) must map to Jira's custom field types because the field type inventory differs; we detect the source plan tier during discovery and skip the custom field step entirely on Free, Starter, or Standard accounts where no custom fields exist. Third, Backlog Wikis use a custom markup format that we convert to plain text or Jira-compatible wiki markup, flagging any macros without a direct equivalent for manual review. We do not migrate Backlog's Gantt chart visualizations, burndown charts, notification settings, or Workflow configurations — these are configuration elements that require rebuild in Jira. The migration uses Backlog's REST API for export and Jira's REST API for import, with empirical rate-limit probing on the Backlog side given that Backlog does not publish specific request-per-minute thresholds.
Every standard and custom field arrives verified.
AI proposes the map; you confirm before any record moves.
Parent–child, lookups, and ownership stay linked.
Calls, emails, meetings — with original timestamps.
Documents, uploads, and inline notes move with the record.
Why teams make this switch
Leaving
What's pushing teams away
Choosing
What's pulling them in
Object mapping
Each row shows how a Backlog object lands in Jira, including any object-level transformations, lookup resolution, or schema-design dependencies.
Typical mapping — final map is confirmed during the sample migration step.
Backlog
Project
Jira
Project
1:1Backlog Projects map directly to Jira Projects as the top-level container. We preserve the project key, name, description, project-level categories, and notification settings. Each Backlog project becomes one Jira project with its own issue type scheme, workflow, and field configuration. Project-level permission schemes are noted for manual configuration in Jira because Jira handles project permissions through permission schemes and project roles rather than Backlog's role model.
Backlog
Issue
Jira
Issue (Story, Task, Bug)
1:1Backlog Issues map to Jira Issues with the type determined by Backlog's issue type name. Standard Backlog issue types (Task, Bug, Story, Enhancement) map to their Jira equivalents via the issue type scheme we configure before migration. Issue summary, description, status, priority, assignee, reporter, due date, start date, estimated hours, and spent hours all map to typed Jira fields. We preserve issue key references and Backlog's issue ID in a custom field backlog_issue_id__c for traceability.
Backlog
Subtask
Jira
Subtask
1:1Backlog Subtasks map to Jira Subtask issue types linked to their parent Issue via the Jira Subtask issue link. We configure the Jira issue type scheme to include Subtask before migration. The subtask status, assignee, priority, and description migrate directly; estimated and logged hours are preserved as subtask fields. Parent issue ID is resolved at migration time using the backlog_issue_id__c custom field to maintain the parent-child relationship across the API import.
Backlog
Custom Field (Premium+)
Jira
Custom Field
lossyBacklog Custom Fields exist only on Premium and Enterprise plans. On Free, Starter, and Standard accounts, this step is skipped entirely — we detect the plan tier during discovery and proceed without custom field mapping if none are configured. On Premium accounts, we map Backlog field types (text, numeric, date, list, multi-list, checkboxes, radio, dropdown) to the closest Jira custom field type (Free Text, Number, Date Picker, Select, Multi-Select, Checkboxes, Radio Buttons, Cascading Select). Fields that cannot map directly become Jira Free Text fields, and any unmappable field type is flagged in the reconciliation report.
Backlog
Tag
Jira
Label
1:1Backlog Tags are free-form flat labels applied to issues. They map directly to Jira Labels, which are single-value string fields on Jira issues. Backlog's tag set is reconstructed as a Jira label scheme. Jira Labels are not hierarchical, matching Backlog's tag model, so no structural transformation is required.
Backlog
Milestone (Version)
Jira
Version
1:1Backlog Milestones (called Versions in the Backlog UI) map to Jira Versions attached to the corresponding project. We preserve the milestone name, planned release date, and description. Issue-milestone associations migrate as Jira fixVersion references on each affected Issue, so the backlog of issues in a given release is visible directly in the Jira release report.
Backlog
Category
Jira
Component
1:1Backlog Categories group issues at the project level and can represent product areas, services, or team assignments. We map them to Jira Components within each project. Component lead, description, and assignee are preserved where configured in Backlog. Issues are linked to their Component via the Component field on the Jira issue.
Backlog
User
Jira
User
1:1Backlog Users are mapped to Jira Users by email address match. User display name, email, and role are extracted from Backlog. Any Backlog user without a matching Jira account is flagged in the reconciliation report for the customer's admin to provision before the record import phase. Jira requires an active or inactive user to be present before Owner or Assignee fields can be populated.
Backlog
Team (Group)
Jira
Group
1:1Backlog Teams are group-level assignments that can be assigned to issues rather than individual users. We map Teams to Jira Groups. Team membership and team-issue assignments are preserved as Jira group memberships on the relevant issues. Jira Groups are used for notifications and project role membership but do not replace individual User assignment as issue Owner or Assignee.
Backlog
Wiki Page
Jira
Page
1:1Backlog Wiki pages are project-scoped and use a custom Backlog wiki markup format. We extract page content, titles, hierarchy (parent-child page relationships), and internal wiki links. Backlog wiki markup is converted to plain text or Jira-supported wiki markup, preserving headings, lists, code blocks, tables, and internal page references. Pages without a clear markup equivalent are flagged in the handoff report for manual review. Jira does not have a native wiki — Confluence is the Atlassian wiki product — so migrated pages land as plain-text or lightly formatted pages in Jira's description and comments fields.
Backlog
Git Repository
Jira
Repository (Jira Software)
1:1Backlog Git and Subversion repositories are project-scoped. Repository names, URLs, and the repository description migrate as Jira Software repository references if the destination Jira instance has Jira Software Development panel enabled. The actual source code does not migrate. We document repository URLs and any linked issue keys for the customer's development team to re-establish CI/CD links in their pipeline.
Backlog
Pull Request
Jira
Pull Request (Jira Software)
1:1Backlog pull request metadata (title, description, reviewers, status, comments) linked to Git repositories migrates as Jira Development panel data associated with the mapped Jira issue. PR status (Open, Merged, Declined) is preserved as a comment on the Jira issue with PR title and link. Actual diff and code review comments do not migrate. PR-to-issue links are reconstructed using the Backlog issue key embedded in the PR title or description field.
| Backlog | Jira | Compatibility | |
|---|---|---|---|
| Project | Project1:1 | Fully supported | |
| Issue | Issue (Story, Task, Bug)1:1 | Fully supported | |
| Subtask | Subtask1:1 | Fully supported | |
| Custom Field (Premium+) | Custom Fieldlossy | Fully supported | |
| Tag | Label1:1 | Fully supported | |
| Milestone (Version) | Version1:1 | Fully supported | |
| Category | Component1:1 | Fully supported | |
| User | User1:1 | Fully supported | |
| Team (Group) | Group1:1 | Fully supported | |
| Wiki Page | Page1:1 | Fully supported | |
| Git Repository | Repository (Jira Software)1:1 | Fully supported | |
| Pull Request | Pull Request (Jira Software)1:1 | Fully supported |
Gotchas + challenges
Platform-specific issues from each side, plus the pair-specific challenges that don't show up on either platform's page on its own.
Backlog gotchas
Free and Starter tiers enforce hard project-count limits
Custom Fields are tier-gated — not available below Premium
CSV and Excel exports omit full issue descriptions
API rate limit numbers are not publicly documented
Wiki markup must be converted to destination format
Jira gotchas
Unsupported workflow validators silently skipped during migration
Custom fields converted to flat text labels when migrating to non-Jira platforms
Historical status-change timestamps lost when exporting without a Marketplace plugin
Attachment import failures from oversized files and JQL reference corruption
Points-based API rate limits enforced on Jira Cloud apps from March 2026
Pair-specific challenges
Migration approach
Discovery and plan-tier audit
We audit the Backlog space via the REST API to enumerate all projects, issues, subtasks, milestones, categories, custom fields, users, teams, wikis, and repositories. We detect the plan tier from the presence or absence of the custom fields endpoint response. We count issue and subtask totals, measure API responsiveness to establish batch sizing, and inventory any Backlog Premium features (custom fields, unlimited Gantt view) in use. The discovery output is a written migration scope covering record counts, schema dependencies, and any tier-gated features that require action before migration.
Jira project schema design
We design the destination Jira project structure before any data moves. This includes creating the Jira Project with the appropriate key, provisioning the issue type scheme (Story, Task, Bug, Subtask enabled), creating the workflow with all migrated status transitions, configuring the Jira board with columns mapped to status values, setting up fix versions (Jira Versions mapped from Backlog Milestones), and adding any custom fields to match the Backlog Premium custom field inventory. All schema design is validated in a Jira Sandbox or test project before production migration begins.
Sandbox migration and reconciliation
We run a full migration into a Jira Sandbox environment using the full production data volume. The customer reconciles record counts (Projects in, Issues in, Subtasks in, Versions in), spot-checks 25-50 issues across projects against the Backlog source for data accuracy, and validates the subtask hierarchy is intact with correct parent links. The Jira admin confirms board column mapping reflects the migrated status values. Sign-off on the sandbox migration is a precondition for production cutover.
User and group provisioning
We extract every distinct Backlog user and team referenced as assignee, reporter, or owner across all issues, subtasks, and milestones. Users are matched to Jira accounts by email address. Any Backlog user without a matching Jira account is added to the reconciliation report. Jira Groups are created to match Backlog Teams, and team memberships are preserved. Jira Groups and Users must be provisioned before the record import phase because Jira requires a valid Owner and Assignee reference for each issue.
Production migration in dependency order
We run the production migration in this sequence: Jira Project and Version creation, then Issues (parent records first), then Subtasks with parent ID resolution, then custom fields (Premium accounts only), then labels, then attachments (by URL reference), then Git PR metadata as Jira Development panel comments, then wiki content as Jira page descriptions. Each phase emits a row-count reconciliation report. If the migration is interrupted, we resume from the last completed phase using Jira issue keys as the dedupe anchor rather than reprocessing completed records.
Cutover, validation, and automation handoff
We freeze Backlog writes during the cutover window, run a final delta scan for any records modified during migration, then mark Jira as the system of record. We deliver a written inventory of all Backlog workflow configurations, automation rules, and notification settings requiring rebuild in Jira. We do not rebuild these as Jira workflows, automation rules, or board filters — that is an admin task or a separate engagement. We support a three-business-day hypercare window to resolve data reconciliation issues raised by the team after cutover.
Platform deep dives
Backlog
Source
Strengths
Weaknesses
Jira
Destination
Strengths
Weaknesses
Complexity grading
Standard Project Management migration. 3 of 8 objects need a mapping; the rest are 1:1.
Overall complexity
Standard migration
Derived from compatibility, mapping clarity, API constraints, and data volume across Backlog and Jira.
Object compatibility
3 of 8 objects need a mapping; the rest are 1:1.
Field mapping clarity
Field mapping is derived from defaults — final spec confirmed during the sample migration.
Timeline complexity
8-object category — typical timelines run 2–7 days end-to-end.
API constraints
Backlog: Per-minute, per-user limits that vary by plan (Free vs Paid) and by request type; exact numbers are dynamic and exposed via the GET /api/v2/rateLimit endpoint.
Data volume sensitivity
Backlog exposes a bulk API — large-volume migrations stream efficiently.
Estimator
Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.
Step 1
Pick a category, then your source and destination platforms.
Category
FAQ
Answers to the questions buyers ask most during Backlog to Jira migration scoping. Not seeing yours? Book a call.
Walk through your Backlog to Jira migration with a real engineer — 30 minutes, free, written quote within 24 hours.
Book a free 30 minute consultationAdjacent paths
Other ways to leave Backlog
Other ways to arrive at Jira
Same-Project Management migrations
Ready when you are
Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.