Project Management migration
Field-level mapping, validation, and rollback between TaskRay and Jira. We move data and schema; workflows are rebuilt natively in Jira.
TaskRay
Source
Jira
Destination
Compatibility
10 of 13
objects map 1:1 between TaskRay and Jira.
Complexity
BStandard
Timeline
3-5 weeks
Overview
Moving from TaskRay to Jira is a structural translation, not a direct record copy. TaskRay's hierarchical model (Projects → Task Groups → Sub-Projects → Tasks → Milestones) has no single Jira equivalent — we decompose it into Jira Projects with appropriate issue types (Epic, Story, Task, Subtask) and Jira's native hierarchy within issues. TaskRay Resources map to Jira Users by email match, and TaskRay Dependencies migrate as Jira Issue Links (Blocks / is blocked by). Since TaskRay exposes no standalone API and lives inside Salesforce, all export runs through Salesforce REST or Bulk API with edition-gated rate limits; Jira write operations use Jira's REST API with its own concurrency model. Custom fields require a mapping pass because TaskRay custom fields live in Salesforce while Jira custom fields live in Jira's own schema. We do not migrate TaskRay Templates, Automations, or Dashboards as code — we deliver a written inventory for the customer's admin to rebuild in Jira.
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 TaskRay 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.
TaskRay
TaskRay Project
Jira
Jira Project
1:1TaskRay Project__c records map to Jira Projects. The Jira Project key (e.g. PROJ) is assigned during import, and the Project name maps from TaskRay Project Name. Project Start and End dates can be stored as Jira Project dates or as custom fields if the Jira instance has the Dates of Project macro enabled. Archived projects in TaskRay map to Archived status in Jira if supported by the Jira edition.
TaskRay
TaskRay Sub-Project
Jira
Jira Epic
1:manyTaskRay Sub-Projects represent child project structures within a parent Project. In Jira, Sub-Projects are modeled as Epic issues within the target Jira Project, with the Epic summary matching the Sub-Project name. If the customer prefers separate Jira Projects per Sub-Project, we can provision one Jira Project per Sub-Project and nest them under the parent Jira Project using the Project hierarchy feature available on Jira Premium.
TaskRay
TaskRay Task Group
Jira
Jira Issue Type (Story or Task)
1:manyTaskRay Task Groups represent phases or themes within a project. Jira has no native phase grouping object, so Task Groups map to Jira Epic (if they contain multiple child issues) or to a Jira label prefixed with tg- for identification. The grouping logic is applied during scoping — if the customer relies heavily on Task Groups for reporting, we configure a Jira Epic per Task Group or a custom Jira label field.
TaskRay
TaskRay Task
Jira
Jira Issue (Story or Task)
1:1TaskRay Task__c records map to Jira Issues of type Story or Task. The mapping uses Task Name as Issue Summary, Task Description as Issue Description, Task Status as Jira Status (mapped via a status translation table we build during scoping), and TaskRay Assignee email matched to Jira User by email. Checklist items are handled separately as Jira subtasks or linked issues.
TaskRay
TaskRay Milestone
Jira
Jira Issue (Task with Milestone label)
1:1TaskRay Milestones are single-day tasks visually rendered as diamonds in Plan View. Jira has no native milestone object, so we map Milestones to Jira Issues of type Task with a Milestone label and the milestone date stored in a custom date field. If Jira has the Advanced Roadmaps or Structure add-on, milestones can alternatively map to Roadmap milestones.
TaskRay
TaskRay Checklist and Checklist Item
Jira
Jira Subtask or Linked Issue
lossyTaskRay Checklist Items are granular sub-todo states (checked/unchecked) under a Task. Jira has no native checklist object. We offer two migration paths: (1) Jira Subtasks — each Checklist Item becomes a Jira Subtask under the parent Issue; (2) Linked Issues — each Checklist Item becomes a linked Issue of type Task with a Blocks link back to the parent Jira Issue. The customer selects the strategy during scoping. Completion status migrates as Issue resolution (Done / Open).
TaskRay
TaskRay Dependency
Jira
Jira Issue Link (Blocks / is blocked by)
1:1TaskRay predecessor/successor links between Tasks map to Jira Issue Links. The TaskRay dependency type (Finish-to-Start, Start-to-Start, etc.) is stored in a custom Jira Issue Link type if required; otherwise, we default to Blocks / is blocked by links which Jira renders in the dependency view. We validate all links after import to ensure the target issue IDs exist in the destination Jira instance.
TaskRay
TaskRay Resource / Role
Jira
Jira User and Project Role
1:1TaskRay Resources (individual users) map to Jira Users resolved by email address. Any TaskRay Resource without a matching Jira User is held in a reconciliation queue for the customer's Jira admin to provision before record import. TaskRay Roles (placeholder job-function owners) map to Jira Project Roles (e.g. Developers, Designers) if the Jira project uses role-based assignment; otherwise, they map to Jira Groups.
TaskRay
TaskRay Custom Fields (Project, Task, TaskGroup)
Jira
Jira Custom Fields
1:1TaskRay custom fields exist as Salesforce custom fields on TaskRay__Project__c, TaskRay__TaskGroup__c, and TaskRay__Task__c objects. We detect all custom fields during export, map them to equivalent Jira custom field types (text, date, select, multi-select, user picker) based on Salesforce field type, and configure them in the destination Jira Project before import. Custom field IDs differ between Salesforce and Jira so the mapping pass is required before any data insert.
TaskRay
TaskRay Template
Jira
Jira Project Template (manual rebuild)
1:1TaskRay Template Projects and the Template Migration feature (Premium-only) allow reusable project skeletons in Salesforce. Jira Project Templates serve a similar function. However, we do not migrate TaskRay Templates as Jira Templates because the data structures are incompatible. We deliver a written template inventory documenting every TaskRay template's structure (Task Groups, Tasks, Milestones, Dependencies, Checklist configurations) for the customer's admin to recreate as a Jira Project Template or using Jira's Quickstart functionality.
TaskRay
TaskRay File / Attachment
Jira
Jira Issue Attachment
1:1TaskRay stores files on the Salesforce ContentDocumentLink model, accessible via Salesforce file APIs. We export files attached to TaskRay records and re-attach them to the corresponding Jira Issues via the Jira REST API attachment endpoint (POST /rest/api/3/issue/{issueIdOrKey}/attachments). Null-filename attachments are flagged and excluded per Jira's attachment requirements. Large attachments (over 10 MB per Jira's single-file limit) are chunked and retried with exponential backoff.
TaskRay
TaskRay Chatter Thread
Jira
Jira Issue Comment
1:1TaskRay Project and Task records can contain Chatter threads for team discussion. Chatter posts map to Jira Issue Comments. The Chatter post author and timestamp are preserved in the Jira comment author and timestamp fields. Rich text in Chatter migrates as plain text or Jira-flavored Markdown depending on the content complexity.
TaskRay
TaskRay Resource Capacity / Utilization (Premium)
Jira
Jira Capacity Planning (via Marketplace app)
1:1TaskRay Resource Capacity and Utilization data (Premium tier) are stored as custom fields on Resources and are migratable. Jira has no native capacity planning in the base product — teams needing this capability typically add Jira Product Discovery or a Marketplace app (Tempo, Structure). We migrate the capacity numeric values as Jira custom number fields for reference, but capacity planning workflows require a separate tool selection and configuration post-migration.
| TaskRay | Jira | Compatibility | |
|---|---|---|---|
| TaskRay Project | Jira Project1:1 | Fully supported | |
| TaskRay Sub-Project | Jira Epic1:many | Fully supported | |
| TaskRay Task Group | Jira Issue Type (Story or Task)1:many | Fully supported | |
| TaskRay Task | Jira Issue (Story or Task)1:1 | Fully supported | |
| TaskRay Milestone | Jira Issue (Task with Milestone label)1:1 | Fully supported | |
| TaskRay Checklist and Checklist Item | Jira Subtask or Linked Issuelossy | Fully supported | |
| TaskRay Dependency | Jira Issue Link (Blocks / is blocked by)1:1 | Fully supported | |
| TaskRay Resource / Role | Jira User and Project Role1:1 | Fully supported | |
| TaskRay Custom Fields (Project, Task, TaskGroup) | Jira Custom Fields1:1 | Fully supported | |
| TaskRay Template | Jira Project Template (manual rebuild)1:1 | Fully supported | |
| TaskRay File / Attachment | Jira Issue Attachment1:1 | Fully supported | |
| TaskRay Chatter Thread | Jira Issue Comment1:1 | Fully supported | |
| TaskRay Resource Capacity / Utilization (Premium) | Jira Capacity Planning (via Marketplace app)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.
TaskRay gotchas
No standalone API — migration runs through Salesforce
Licensing count explosion during inbound migration
No native cost or invoice objects
Field Trickler lookups require post-migration validation
Sub-Project hierarchy depth limits
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 Salesforce API profiling
We audit the source TaskRay Salesforce org across Salesforce edition, installed TaskRay version (Starter/Standard/Premium), API call usage trends, and record volumes per object. We profile API rate limit headroom to determine the migration throughput ceiling and decide whether Bulk API 2.0 is required for large datasets. We also inventory TaskRay custom fields, checklist configurations, dependency chains, and template count during this phase. The discovery output is a written migration scope document, a Salesforce API headroom calculation, and a preliminary Jira structure recommendation.
Jira project design and structure mapping
We design the Jira destination structure in parallel with export planning. This includes provisioning the Jira Cloud or Data Center project, configuring issue types (Epic, Story, Task, Subtask), defining the Jira workflow with status transitions, creating Jira custom fields mapped to TaskRay custom fields, and finalizing the hierarchy mapping decision (TaskRay Sub-Project to Jira Epic, TaskRay Task Group to Jira label, etc.). If the customer uses Jira groups for role-based access, we configure those here. The Jira project is validated in a staging environment before production migration begins.
Export from Salesforce and Jira structure provisioning
We extract TaskRay records from Salesforce using REST API (for real-time or low-volume objects) or Bulk API 2.0 (for Tasks, Checklist Items, and Dependencies). Records export in dependency order: Projects first, then Task Groups, then Tasks, then Checklist Items and Dependencies. We capture Salesforce IDs, parent-child relationships, owner email addresses, and custom field values. Salesforce org maintenance windows and weekend batch limits are respected. On the Jira side, we provision the project structure, custom fields, and issue types during this window so that the destination is ready for import before any records are written.
Owner and Resource reconciliation
We extract every distinct TaskRay Resource and Role referenced on Tasks and Projects and match them against Jira Users by email address. Any TaskRay Resource without a matching Jira User account is placed in a reconciliation queue. The customer's Jira admin provisions missing users (or Jira Guest accounts for external stakeholders) before the production import phase. Role placeholders that have no Jira equivalent are converted to Jira Project Roles or Groups during this step.
Production import in dependency order with Jira REST API
We run the production import into Jira in strict dependency order: Jira Project (created first), Epics (from Sub-Projects), parent Issues (from Tasks with Task Groups mapped as labels), then child Issues (from Checklist Items as Subtasks or linked issues), then Dependencies (as Jira Issue Links). Jira has per-minute and per-day API rate limits (1,000 requests per minute on Standard, 10,000 on Premium) that we manage with exponential backoff and batch chunking. Each import phase emits a row-count and error-rate reconciliation report before the next phase begins.
Validation, delta migration, and Template rebuild handoff
We validate Jira import quality by reconciling record counts (TaskRay Tasks in, Jira Issues out), spot-checking 25-50 random issues for field accuracy, and verifying all Dependency links resolve to existing Jira issue keys without dangling references. Any records modified in Salesforce during the migration window are captured in a delta migration pass. We deliver the TaskRay Template inventory document to the customer's admin team with a step-by-step guide for recreating each template as a Jira Project Template. Jira Workflow, automation rules, and Jira Service Management configurations are not migrated; we provide a written automation inventory with recommended Jira Automation rules for each migrated workflow concept.
Platform deep dives
TaskRay
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 TaskRay 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
TaskRay: Not documented for TaskRay specifically — governed by Salesforce API limits (edition-dependent, 1,000–unlimited daily calls).
Data volume sensitivity
TaskRay 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 TaskRay to Jira migration scoping. Not seeing yours? Book a call.
Walk through your TaskRay 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 TaskRay
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.