First page of Microsoft's 100,000-partner directory, sorted by responsiveness Microsoft Solutions Partner — Security, Modern Work, Infrastructure, App Innovation Microsoft partner since 2006 1,100+ organizations under management
Home/Services/Jira to Azure DevOps Migration
MigrationDevelopment

Jira to Azure DevOps Migration

Jira to Azure DevOps Migration moves your Jira Cloud or Jira Data Center projects into Azure Boards — issues, history, comments, attachments and links as far as the migration tool carries them — and, just as importantly, redesigns the workflow around an Azure Boards process your teams can actually live in. Microsoft ships no first-party Jira importer, so IT Partner runs the inventory (projects, issue types, workflows, custom fields, sprints, components, versions, users), makes the process-template decision with you (Agile, Scrum, Basic, CMMI or an inherited process), builds the field, state and user mapping, migrates with Solidify's open-source Jira to Azure DevOps migrator or a commercial migrator named in the quote, designs area paths and iterations, re-points Bitbucket or GitHub repository links, validates against the source, runs the cutover inside an agreed Jira freeze and briefs the team on the new workflow. GitHub Issues and GitHub Projects are an alternative target and are scoped by quote. Estimated at $3,950 per project and about 3 weeks, confirmed as a fixed written quote after the inventory — and you pay after you approve delivery.

Timeline 3 weeksService owner Alex NikulinAzure DevOpsAzure BoardsMicrosoft Entra ID

What this engagement is

Two things push engineering teams off Jira and onto Azure Boards: consolidation and cost. If your pipelines, repositories, artifacts and test plans already live in Azure DevOps — or your identity, licensing and support already live in Microsoft 365 — keeping work tracking in a separate Atlassian tenancy means a second identity model, a second admin surface and a second invoice. Atlassian's own on-premises story pushed the same way: support for Jira Server ended on 15 February 2024, so on-premises estates now run Jira Data Center under licensing terms that are Atlassian's to publish and change. Azure Boards comes with the Azure DevOps Services user licence — Microsoft's per-user charge, billed by Microsoft, not by us — so for most teams the recurring cost question is settled before the migration starts. What is not settled is fidelity. Jira and Azure Boards do not model work the same way, and anyone who tells you this migration is a button is selling you a disappointment. Here is the tooling truth, stated plainly because it shapes the whole engagement. Microsoft's high-fidelity Data Migration Tool imports Azure DevOps Server and TFS collections only; there is no first-party Jira importer. The standard path is Solidify's open-source Jira to Azure DevOps migrator: it exports issues selected by a JQL query into files, then imports them as work items — field data, state, history, comments (written into the work item's history and discussion), attachments and links — with users translated through a mapping file so history keeps its attribution. The Community edition is free. The PRO and suite tiers add releases with the Fix Version and Affects Version fields, sprint dates, Bitbucket branch links, remote (web) links converted to work item hyperlinks, rewriting of embedded Jira issue links so they point at the new work items, state-transition dates for custom workflow states, and — in the suite — Xray, Zephyr and QMetry test data plus Confluence spaces into Azure DevOps wikis. Those licences are Solidify's product and your cost; the inventory tells you whether you need them. Commercial migrators exist too, and where one fits your estate better we name it, and its licence, in the quote. Where the estate is genuinely small, Azure Boards' native CSV import can be the right answer and we will say so — but its limits are real: only parent-child links (expressed by indenting title columns), every new item lands in the New state, area and iteration default to the top-level node, and identities must already match a user principal name in the organization. No comments, no attachments, no history. The migration is the easy half; the mapping is the half you live with for years. Azure Boards gives you four system processes — Basic, Agile, Scrum and CMMI — which Microsoft owns and keeps locked, so anything you want to customise happens in an inherited process derived from one of them. Microsoft's current guidance is that a project's base process is chosen at creation and not casually swapped afterwards, so this is a decision we make in design, before a single issue is imported. Then comes the workbook every honest migration runs on: issue type to work item type; Jira status to Azure Boards state, and to the state category that drives your board columns; Jira custom field to the Azure DevOps field reference name (not the display name — the classic reason a field silently fails to import); Jira link type to the Azure DevOps link type, in the right direction; sprints to the iteration tree; components and versions to area paths, tags or fields. Azure Boards' published limits bound that design — 1,024 fields per process, 64 work item types per process, 32 workflow states per work item type, five portfolio backlog levels, 100 attachments and 60 MB per file on a work item — and we design inside them rather than discovering them mid-import. Where a Jira workflow simply has no Azure Boards equivalent, the workbook says so in writing and proposes the trade-off, rather than quietly dropping it. We run it in one shape: inventory, a mapping workbook you sign off, a pilot migration into a scratch project verified by the people who own the work, the production run inside an agreed Jira freeze, then boards, backlogs, iterations, area paths and permissions configured and a team briefing so the first sprint in Azure Boards is not a support queue. The migrator's own guidance is a full production stop in Jira for the final run — it is a migration tool, not a synchroniser — so we plan the freeze, a delta pass for anything that moved, and Jira left read-only until you choose to cancel it. Boundaries are explicit and we would rather you read them now than discover them later: Confluence content is a separate engagement; Jira Service Management queues, SLAs, request types and customer portals are not Azure Boards work and are scoped separately; an Azure DevOps Server or TFS source is the Azure DevOps Server to Azure DevOps Services Migration service; pipeline work is Azure DevOps and GitHub CI/CD Pipeline Implementation; code repository migration beyond re-pointing links is quoted separately; and if GitHub Issues and GitHub Projects is your real destination, say so — there is no first-party exporter for that path, community importers vary in fidelity, and we quote it as its own project rather than pretending this page covers it.

Success criteria

01The inventory produces a written migration plan: every Jira project with its issue count, issue types, workflows and statuses, custom fields, sprints, components, versions, link types, attachment volume, active and departed users, apps and automation rules — and the list of what is in scope, which is what the fixed quote is built on.
02The target design is agreed and recorded before any import: the Azure DevOps organization and project layout, the process (Basic, Agile, Scrum, CMMI or an inherited process), the area-path and iteration design, and the team structure that will use them.
03The mapping workbook is signed off by your side: issue type to work item type, status to state, field to field reference name, link type to link type, Jira user to Microsoft Entra ID account — with every unmapped item listed by name and its disposition agreed.
04A pilot migration of one representative project lands in a scratch Azure DevOps project and is verified by that project's owner against Jira — hierarchy, states, assignees, comments, attachments, links and sprints — before the production run is scheduled.
05The production migration completes inside the agreed Jira freeze window, and the reconciliation report matches issue counts by type and status, links created, and attachments transferred, with every error from the tool's log accounted for.
06Users sign in to Azure DevOps with their Microsoft Entra ID accounts and find their work assigned to them, with history and comments attributed through the user mapping rather than to a migration service account.
07Boards, backlogs and sprints work on day one: iterations carry the right dates where the tool supports them, board columns follow the mapped states, area paths reflect components or teams, and each team's backlog is populated.
08Repository links are re-pointed or registered: Bitbucket and GitHub links referenced from migrated issues either resolve, or appear on a written list of links that could not be re-pointed and why.
09Jira is read-only from the freeze date, the team has had its briefing and one-page cheat sheet, and the closeout pack documents the mapping, the tool and release used, the reconciliation, and what was deliberately left behind.

What you receive

Jira inventory and fit assessment: projects, issue counts by type and status, workflows and their statuses, custom fields with their screens and contexts, boards, sprints, components, versions, link types, attachment volume, active and inactive users, plus the Marketplace apps, automation rules and integrations attached to each project.
Azure DevOps target design: organization and project layout, the process decision (Basic, Agile, Scrum, CMMI or an inherited process) with the reasoning written down, work item type set, area-path design from components or team structure, iteration tree from your sprint cadence, tag strategy, and the custom fields to be created — all inside Microsoft's published process limits.
The mapping workbook: issue type to work item type, Jira status to Azure Boards state and state category, Jira field to Azure DevOps field reference name, Jira link type to Azure DevOps link type with direction, sprints to iterations, components and versions to area paths, tags or fields — with an explicit 'not migrating' column and your sign-off on it.
The user mapping file: Jira accounts to Microsoft Entra ID user principal names (Jira Cloud maps by account ID unless profile emails are public), a documented decision for departed staff and service accounts, and a default identity for anything unmapped so nothing imports anonymously by accident.
Migrator configuration under source control: the per-project configuration files (field and state maps, link map, epic-link and sprint field names, HTML-rendered mapping for descriptions and comments, sprint mapping to the iteration tree, attachment folder, repository map for development links), the exact tool and release used, and the run commands — so the migration is reproducible rather than a memory.
Tooling recommendation and licence routing: Solidify's Community edition where it suffices, PRO or the Atlassian Migration Suite where you need releases and Fix/Affects Version, sprint dates, Bitbucket branch links, remote-link conversion, embedded-link rewriting or custom state-transition dates, or a named commercial migrator where it fits better — licences purchased by you, and the small-estate CSV import path recommended openly when it is genuinely the cheaper right answer.
Pilot migration into a scratch Azure DevOps project, plus a structured verification session with the project's owner and a written list of mapping corrections applied before the production run.
Production migration executed inside the agreed Jira freeze window, with export and import logs, the tool's journal file retained so failed items can be re-run, and a delta pass for anything created during the freeze.
Reconciliation report: issue counts by project, type and status compared source to target, links created by type, attachments transferred, fields that did not map, and every error in the log with its disposition — fixed, accepted or deliberately out of scope.
Repository link handling: Bitbucket or GitHub references re-pointed where the repositories already live in Azure Repos or GitHub, development links configured through the repository map where the tool and your repository state support it, and a register of links that cannot be re-pointed without a repository migration (which we quote separately).
Azure Boards configuration for go-live: teams, area paths, iteration schedule and sprint dates, backlog levels, board columns and swimlanes matched to the mapped states, queries and a starter dashboard, plus security groups and permissions — including removal of the elevated migration permissions and the migration token when the run is finished.
Team briefing (a working session, not a lecture) with a one-page Jira-to-Azure-Boards cheat sheet, plus written guidance for putting Jira read-only, exporting an archive for the record, and cancelling the subscription on your own timetable.

How the work unfolds

1. Inventory and fit assessment (week 1)

We connect to Jira with a read-only account, inventory every project in scope — issue counts, issue types, workflows and statuses, custom fields, boards, sprints, components, versions, link types, attachment volume, users, apps and automation rules — and check what your Jira edition and API access allow. You get a written plan and the in-scope list, and the estimate becomes a fixed written quote on that basis, before any migration work begins.

2. Target design and mapping workbook (week 1–2)

We agree the Azure DevOps organization and project layout and the process — Basic, Agile, Scrum, CMMI or an inherited process — knowing the base process is a create-time decision rather than something to swap later. Then we build the mapping workbook (issue types, statuses and state categories, fields by reference name, link types, sprints, components and versions) and the user mapping file, and walk you through what will not map one-to-one. Nothing imports until you sign this off.

3. Pilot migration and verification (week 2)

One representative project is migrated into a scratch Azure DevOps project with the real configuration. The owner of that project checks it against Jira — hierarchy, states, assignees, comments, attachments, links, sprints — and we correct the mapping and re-run until it is right. The pilot is where surprises are allowed to happen, and it is also where the production run's duration stops being a guess.

4. Production migration and cutover (week 3)

In the agreed window, Jira goes read-only for the projects in scope, the export and import run project by project with the journal retained so any failed item can be re-run, and a delta pass picks up anything created between the pilot and the freeze. We reconcile counts, links and attachments against the source and hand you the report before we call it done.

5. Boards configuration, briefing and closeout (week 3)

Teams, area paths, iterations and sprint dates, board columns, backlogs, queries and a starter dashboard are configured; elevated migration permissions and tokens are removed; the team gets its briefing and cheat sheet; and the closeout pack documents the mapping, the tool and release used, the reconciliation and the deliberate exclusions — with written guidance for making Jira read-only and retiring it on your schedule.

Prerequisites

Jira administrator access for the projects in scope: an account that can read every issue, comment and attachment, plus an API token. For Jira Cloud, expect user mapping by account ID unless profile emails are public; for Jira Data Center, an account with equivalent project and browse permissions.
An Azure DevOps Services organization you control, with Project Collection Administrator rights to create the target project or projects and to create or edit an inherited process.
A migration account in Azure DevOps with a personal access token scoped to Work Items (read, write and manage), granted 'Bypass rules on work item update' on the target project and 'Create child nodes' on the base area and iteration paths — these are what let history, dates and hierarchy be written faithfully. We remove the elevation at closeout.
Microsoft Entra ID accounts already existing for every user who will be assigned work: Azure DevOps resolves identities that are already in the organization, it does not create them. If your developers are still only in on-premises Active Directory, that is a prerequisite project — see On-premises Active Directory to Microsoft Entra ID Transition.
Azure DevOps Services licensing for your users after cutover — Basic, Stakeholder or a Visual Studio subscription, priced and billed by Microsoft. We confirm what your team needs during the inventory; we do not resell it inside this fee.
A decision, before the target project is created, on which process it is built from — Basic, Agile, Scrum, CMMI or an inherited process — because that choice is made at project creation and reworking it afterwards is a project of its own.
A named owner for each Jira project who will verify the pilot and the production result inside the agreed window, and one decision-maker for the mapping workbook.
Agreement on the freeze date and the read-only period: the migrator is not a synchroniser, so the projects in scope stop taking updates in Jira for the final run.
Disclosure of the Jira apps, automation rules, integrations, webhooks and external collaborators attached to the projects in scope — including test-management apps such as Xray, Zephyr or QMetry — so nothing that depended on Jira breaks silently after cutover.
Network access from the migration workstation to both Jira and Azure DevOps, and somewhere to stage exported files and attachments — a Windows machine is the tool's primary target, and the export volume is sized in the inventory.

Who does what

IT Partner

  • Run the Jira inventory and fit assessment and convert the estimate into a fixed written quote before work begins.
  • Design the Azure DevOps target — project layout, process, work item types, area paths, iterations — and document the reasoning.
  • Build the mapping workbook, the migrator configuration and the user mapping file, and name every item that will not migrate.
  • Recommend the tooling honestly, including when the free Community edition or the native CSV import is sufficient, and when a paid tier or a commercial migrator is genuinely needed.
  • Execute the pilot and the production migration, retain logs and the journal, re-run failed items, and run the delta pass.
  • Reconcile the result against Jira and hand over the report, the configuration and the closeout pack.
  • Configure boards, backlogs, iterations, permissions and queries for go-live, remove the elevated migration access, and brief the team.

Your team

  • Provide Jira administrative access and an API token, and Azure DevOps organization rights for the migration account.
  • Decide the scope: which Jira projects move, which are archived in place, and what is deliberately left behind.
  • Sign off the mapping workbook and the user mapping, including the decisions for departed users and service accounts.
  • Verify the pilot and the production result within the agreed window, through the named owner for each project.
  • Enforce the Jira freeze for the projects in scope during the final run, and communicate it to the teams.
  • Own Azure DevOps Services licensing, any third-party migrator licence, and your Jira subscription decisions — including when to cancel it.
  • Own re-creating anything deliberately out of scope: Jira apps, automation rules, dashboards and integrations beyond what we inventory and recommend.

What's not included

Confluence content. Confluence spaces are a separate engagement whether the destination is SharePoint Online — see Confluence to SharePoint Online Migration — or Azure DevOps wikis: different tooling, different information architecture, different sign-off.
Jira Service Management: queues, request types, SLAs, approvals, customer portals and knowledge base. Azure Boards is a work-tracking system, not a service desk; a JSM replacement is scoped separately and usually lands on different Microsoft products.
Azure DevOps Server or Team Foundation Server sources — that is Microsoft's own Data Migration Tool path, covered by Azure DevOps Server to Azure DevOps Services Migration.
Pipeline design and build: converting Jenkins, Bamboo or Bitbucket Pipelines to Azure Pipelines or GitHub Actions, YAML pipeline authoring, approval gates and environments — see Azure DevOps and GitHub CI/CD Pipeline Implementation, and code scanning, secret protection and dependency review on the GitHub side are GitHub Advanced Security and DevSecOps Implementation.
Code repository migration. We re-point links from migrated work items to repositories that already exist in Azure Repos or GitHub; moving Bitbucket or other repositories themselves, with branches, pull request history and permissions, is quoted separately.
Re-creating Jira apps and automation rules — Automation for Jira rules, ScriptRunner scripts, Marketplace app behaviour — as Azure Boards rules, webhooks or Power Automate flows. We inventory them and recommend equivalents; building them is separate work, often Business Process Automation Using Built-in Microsoft 365 Tools and Services.
Test-management data from Xray, Zephyr or QMetry into Azure Test Plans. It needs different tooling (Solidify's suite tier or an equivalent) and its own verification pass; we quote it as an add-on when the inventory finds it.
Advanced Roadmaps plans, Jira dashboards and reports, Insight/Assets data, and portfolio structures. Azure Boards equivalents are designed and built as a separate exercise, not recreated implicitly by the import.
Two-way synchronisation or long-term coexistence between Jira and Azure Boards. The migrator is explicitly a one-time migration tool; if you need both systems live and in sync, that is a different product category and a different engagement.
GitHub Issues and GitHub Projects as the destination. It is a legitimate target and we will scope it — but neither Atlassian nor GitHub ships a first-party Jira exporter for it, community importers vary in fidelity (single milestone versus multiple fix versions, custom fields, votes and watchers), and it is quoted as its own project rather than folded into this fee.
Azure DevOps Services user licensing and any third-party migrator licence — Microsoft's and the vendor's charges, paid by you. We confirm what is needed during the inventory.
Ongoing administration of the Azure DevOps organization after closeout — process changes, new projects, permission management — available separately if you want it.
Decommissioning execution of Jira itself, or cancellation of your Atlassian subscription. We provide written guidance and an archive checklist; the timing and the commercial decision stay yours.

Limitations & technical notes

!There is no first-party Microsoft importer for Jira. Microsoft's Data Migration Tool covers Azure DevOps Server and TFS collections only, so fidelity here is bounded by the third-party tool used — which is why we name the tool, its edition and its release in the quote and in the closeout pack.
!Solidify's migrator officially supports Jira Cloud and Jira Server 7.x, 8.x and 9.x as sources, and Azure DevOps Services, Azure DevOps Server 2019/2020/2022 and TFS 2018 Update 3 as targets. Jira Data Center instances are validated against your specific version during the inventory rather than assumed, and the tool's documented behaviour on the day is what we plan against.
!The tool documents its own limits: artifact links other than Git links are not migrated, and board fields are not migrated. Releases with Fix Version and Affects Version, sprint dates, Bitbucket branch links, remote-link conversion, embedded-link rewriting and transition dates for custom workflow states are paid-tier features — without that licence they are mapped to something simpler (tags or notes) or listed as not migrating.
!Comments migrate into the work item's history and discussion, and attribution depends entirely on the user mapping. Users who are not mapped fall back to a default identity, so departed staff and service accounts need an explicit decision. Jira Cloud maps by account ID unless profile emails are public — a privacy setting on your side, not a tool defect.
!Workflows and fields do not map one-to-one, and no tool changes that. Azure Boards system processes (Basic, Agile, Scrum, CMMI) are locked by Microsoft; customisation happens in an inherited process; and Microsoft's guidance is that a project's base process is chosen at creation rather than swapped later. The mapping workbook is where those trade-offs are made visible and agreed in writing.
!Azure Boards platform limits bound the design: 1,024 fields per process and per work item type, 8,192 fields per organization, 64 work item types per process, 32 workflow states per work item type on the inheritance model, five portfolio backlog levels, 100 attachments and 60 MB per file on a work item, and 1,000,000 characters in a long-text field. Verified against Microsoft's published work-tracking limits in September 2026; Microsoft can change them.
!The native CSV import path is far more limited than the migrator and we only propose it for genuinely small, simple sets: it carries parent-child links only (through indented title columns), forces new work items into the New state, defaults area and iteration to the top-level node unless specified, requires identities to match a user principal name already in the organization, and carries no comments, attachments or history.
!Jira's own CSV export is capped and omits comments, attachments and change history, and Atlassian has moved the cap more than once and applies it differently in Cloud and Data Center. Migrations therefore read the Jira API rather than a spreadsheet, and the API's rate limits and your Jira plan's permissions affect how long a run takes.
!This is a migration, not a synchronisation. The tool's own guidance is a full production stop in Jira for the final run, so a freeze window and a delta pass are part of the plan, and 'run both for a few months' is a different kind of project.
!Attachment volume is the usual reason a run takes longer than expected: every file is pulled from Jira and re-uploaded to Azure DevOps, subject to the 100-attachment and 60 MB per file limits. The pilot is what turns the production run's duration from an estimate into a measurement.
!GitHub Issues and GitHub Projects as a destination is lower fidelity than Azure Boards by nature — no first-party exporter exists, community importers differ in what they carry, and structures like multiple fix versions, custom fields, votes and watchers have no direct equivalent. We will scope it honestly and quote it separately rather than imply parity.
!The $3,950 price is an estimate for an engagement covering the Jira projects you nominate in the inventory, from a single Jira site, using the tooling the inventory selects. The inventory converts it into a fixed written quote — which you approve before migration work begins and pay after you approve delivery. Larger estates, multiple Jira sites, very high issue or attachment volumes, heavy custom-field estates, test management data and repository migration are quoted there rather than discovered mid-project.
!Technical content reviewed September 2026 against the migration tool's published documentation and Microsoft's published Azure Boards and process limits. Both platforms change; the inventory is always run against what ships on the day.

Frequently asked questions

What is the Jira to Azure DevOps migration service?

It is a fixed-scope project in which IT Partner moves the Jira Cloud or Jira Data Center projects you nominate into Azure Boards: inventory, target design and process choice, the field, state, link and user mapping workbook, a verified pilot, the production migration inside an agreed Jira freeze, reconciliation, boards and iteration configuration, and a team briefing. Estimated at $3,950 per project and about 3 weeks, confirmed as a fixed written quote after the inventory, with payment after you approve delivery.

Does Microsoft provide a Jira importer?

No. Microsoft's Data Migration Tool imports Azure DevOps Server and TFS collections, not Jira. The standard path is Solidify's open-source Jira to Azure DevOps migrator, which exports issues by JQL query and imports them as work items with field data, state, history, comments, attachments and links; commercial migrators are the alternative where they fit better, and Azure Boards' native CSV import covers genuinely small, simple sets. We name the tool, edition and release we will use in the quote.

Do comments, attachments and history come across?

Yes, to the extent the tool documents. Comments are written into the work item's history and discussion, attachments are downloaded from Jira and re-uploaded to the work item (within Azure DevOps' 100 attachments and 60 MB per file limits), and issue history is replayed as revisions so created and changed dates survive. Attribution depends on the user mapping: mapped users keep their names, unmapped ones fall back to a default identity, which is why departed staff and service accounts get an explicit decision in the workbook.

What happens to our Jira workflows and custom fields?

They get redesigned, not copied — that is the consulting half of this engagement. Each Jira status maps to an Azure Boards state and its state category (which drives board columns), each custom field maps to an Azure DevOps field by reference name, and anything without an equivalent is listed by name with a proposed trade-off. Fields you no longer use are a good thing to leave behind, and the workbook is where that conversation happens, before the import rather than after.

Which Azure Boards process should we choose?

Basic for the lightest tracking (Epic, Issue, Task), Agile if you track user stories with separate test work, Scrum if you run product backlog items and sprints, CMMI if you need formal change control with requirements, change requests, risks and reviews — or an inherited process derived from one of them when you need custom fields, states or work item types. Microsoft owns and locks the four system processes, and the base process is chosen when the project is created, so we make this decision in design and not after the import.

What about sprints, epics, components and versions?

Sprints map to the Azure Boards iteration tree, with sprint dates carried where the tool tier supports them; Jira epics map to the parent-child hierarchy through the epic link field; components usually become area paths or tags depending on whether they represent teams or categories; and versions map to Fix Version and Affects Version fields or to tags, with full release migration being a paid-tier feature. Every one of those choices is written in the mapping workbook and shown to you in the pilot.

Do we have to pay for a migration tool?

Not necessarily. Solidify's Community edition is free and open source and covers most migrations. The PRO and suite tiers are subscriptions bought from the vendor and add releases and Fix/Affects Version, sprint dates, Bitbucket branch links, remote-link conversion, rewriting of embedded Jira links, custom state-transition dates and — in the suite — test management and Confluence wikis. If your estate needs those, the licence is your cost and we say so in the inventory rather than burying it in the fee.

Can you keep Jira and Azure Boards in sync during a transition?

Not with this service. The migrator is explicitly a one-time migration tool and its own guidance is a production stop in Jira for the final run; long-running two-way synchronisation is a different product category with its own licences and its own failure modes. What we do plan is a short freeze, a delta pass for anything created in it, and Jira left read-only so nobody loses a reference.

What about our Bitbucket or GitHub repositories?

This engagement re-points links so migrated work items point at repositories that already live in Azure Repos or GitHub, and configures development links where the tool and your repository state support it. Moving the repositories themselves — branches, tags, pull request history, permissions — is a separate quoted project. Anything we cannot re-point is listed in writing rather than left to be discovered.

Can you migrate us to GitHub Issues or GitHub Projects instead?

Yes, as a separately quoted project, and with the fidelity stated up front. Neither Atlassian nor GitHub ships a first-party Jira exporter for that path, so it relies on community importers whose coverage varies — a Jira issue with several fix versions has one GitHub milestone to land in, custom fields become labels or body text, and votes and watchers do not carry. If GitHub is where your teams already work, that may still be the right destination; tell us and we will scope the honest version of it.

What about Confluence and Jira Service Management?

Both are out of scope here and both are real projects in their own right. Confluence spaces move to SharePoint Online — that is Confluence to SharePoint Online Migration — or to Azure DevOps wikis, with different tooling and a different information architecture in each case. Jira Service Management — queues, request types, SLAs, approvals and the customer portal — is a service desk, and Azure Boards is not one; replacing it lands on different Microsoft products and is scoped separately.

How much downtime does the team have?

Your teams work normally in Jira through the inventory, the mapping workbook and the pilot. The only stop is the freeze for the projects in scope during the production run, and its length is measured from the pilot rather than guessed — it is driven by issue count, attachment volume and Jira API throughput. After cutover, Jira stays read-only as a safety net until you decide to retire it.

What happens if some issues fail to import?

They are logged, not lost. The tool keeps a journal of what has been imported, so a run can be resumed and failed items re-run after the configuration is corrected — a mistyped field reference name is the classic cause. The reconciliation report compares counts by project, type and status against Jira, lists links and attachments transferred, and shows every error with its disposition before we call the migration complete.

What does Azure DevOps cost after the migration?

Azure DevOps Services is billed by Microsoft per user: Stakeholder access is free, the first five Basic users in an organization are free on Microsoft's published pricing, Visual Studio subscribers are typically covered, and additional Basic users are paid monthly. We confirm what your team needs during the inventory, but check the current rates against Microsoft's published pricing — they are Microsoft's numbers, not ours, and they change on Microsoft's schedule.

Why is the price an estimate, and when does it become fixed?

$3,950 is the typical price for migrating the Jira projects you nominate from a single Jira site with the tooling the inventory selects. The inventory in week one turns it into a fixed written quote — covering the number of projects and issues in scope, the tool tier, and any add-ons such as test management or repository work — which you approve before migration work begins. Per IT Partner's standard terms, you pay after you approve delivery.

We have hundreds of Jira projects. Does this still apply?

The shape does; the price does not. Large estates are quoted per estate after the inventory, usually as waves: a pilot wave that proves the mapping, then batches grouped by team or process so each freeze is short and each verification has a real owner. The inventory is where 'migrate everything' becomes a list with counts against it — and where archiving dead projects in place often removes more work than any tool does.

Didn’t find your question?

Ask it here. A real engineer answers by email within one business day — and if it’s a good one, it becomes part of this page so the next person finds it.

Answered by a person, one time, to your inbox. Nothing you type here is published without a human reviewing and anonymizing it first.

Often combined with

$3,950 per project
3 weeks
Book a Jira migration assessment