Project Management migration

Migrate from TaskRay to Jira

Field-level mapping, validation, and rollback between TaskRay and Jira. We move data and schema; workflows are rebuilt natively in Jira.

TaskRay logo

TaskRay

Source

Jira

Destination

Jira logo

Compatibility

77%

10 of 13

objects map 1:1 between TaskRay and Jira.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

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.

Field-level fidelity

Every standard and custom field arrives verified.

Schema-aware mapping

AI proposes the map; you confirm before any record moves.

Relationships preserved

Parent–child, lookups, and ownership stay linked.

Full activity history

Calls, emails, meetings — with original timestamps.

Attachments & notes

Documents, uploads, and inline notes move with the record.

Why teams make this switch

Two sides of the same decision

Leaving

TaskRay logo

TaskRay

What's pushing teams away

  • TaskRay covers only 34% of PMI project management processes — it scores 0% on cost management and procurement, and lacks native billing or invoicing entirely, forcing teams to buy a separate PSA for revenue-generating services.
  • High per-user licensing cost ($60/user/month on Premium) adds up quickly when every viewer and task assignee on a project requires a license, making it expensive for large implementation teams.
  • Core PSA features like expense tracking, budget-to-actual reporting, and purchase order management are absent, prompting teams to migrate to Kantata, Certinia, or similar full-suite PSA platforms.
  • Limited email notification flexibility — out-of-the-box assignment notifications lack customization depth, frustrating teams with specific communication workflow requirements.
  • Lack of native integrations beyond Salesforce means complex multi-system environments need custom development to push project data elsewhere.

Choosing

Jira logo

Jira

What's pulling them in

  • 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.
  • Visibility features — boards, backlog grooming, sprint reports, and dashboards — give leadership a shared view of what is planned, in progress, blocked, and done.

Object mapping

How TaskRay objects map to Jira

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

maps to

Jira

Jira Project

1:1
Fully supported

TaskRay 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

maps to

Jira

Jira Epic

1:many
Fully supported

TaskRay 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

maps to

Jira

Jira Issue Type (Story or Task)

1:many
Fully supported

TaskRay 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

maps to

Jira

Jira Issue (Story or Task)

1:1
Fully supported

TaskRay 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

maps to

Jira

Jira Issue (Task with Milestone label)

1:1
Fully supported

TaskRay 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

maps to

Jira

Jira Subtask or Linked Issue

lossy
Fully supported

TaskRay 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

maps to

Jira

Jira Issue Link (Blocks / is blocked by)

1:1
Fully supported

TaskRay 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

maps to

Jira

Jira User and Project Role

1:1
Fully supported

TaskRay 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)

maps to

Jira

Jira Custom Fields

1:1
Fully supported

TaskRay 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

maps to

Jira

Jira Project Template (manual rebuild)

1:1
Fully supported

TaskRay 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

maps to

Jira

Jira Issue Attachment

1:1
Fully supported

TaskRay 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

maps to

Jira

Jira Issue Comment

1:1
Fully supported

TaskRay 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)

maps to

Jira

Jira Capacity Planning (via Marketplace app)

1:1
Fully supported

TaskRay 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.

Gotchas + challenges

What specifically takes care here

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 logo

TaskRay gotchas

High

No standalone API — migration runs through Salesforce

High

Licensing count explosion during inbound migration

High

No native cost or invoice objects

Medium

Field Trickler lookups require post-migration validation

Medium

Sub-Project hierarchy depth limits

Jira logo

Jira gotchas

High

Unsupported workflow validators silently skipped during migration

High

Custom fields converted to flat text labels when migrating to non-Jira platforms

Medium

Historical status-change timestamps lost when exporting without a Marketplace plugin

Medium

Attachment import failures from oversized files and JQL reference corruption

Medium

Points-based API rate limits enforced on Jira Cloud apps from March 2026

Pair-specific challenges

  • TaskRay exports run through Salesforce, not a TaskRay API

    TaskRay exposes no standalone REST or GraphQL API. Every export operation — Projects, Task Groups, Tasks, Milestones, Checklists, Dependencies, Resources — runs through Salesforce's standard REST API, Bulk API 2.0, or Data Loader. Migration throughput is gated by the customer's Salesforce edition: Essentials allows 1,000 API calls per day, Professional allows 15,000, and Enterprise and Unlimited remove the daily cap but apply per-minute concurrency limits. We profile the Salesforce org's API usage during discovery, reserve API headroom for active business operations during migration, and prefer Bulk API 2.0 for large record volumes to minimize API call counting. Jira write operations use Jira's REST API v3 with separate rate limits that we manage independently.

  • TaskRay hierarchy requires deliberate Jira structure mapping

    TaskRay's four-level project hierarchy (Project → Task Group → Sub-Project → Task) has no direct Jira equivalent. Jira organizes work within a flat project container using issue types and within-issue subtask hierarchy. We must decide during scoping how each TaskRay level maps to Jira: Sub-Projects often become Jira Epics or separate Jira Projects; Task Groups become Jira labels or Epic-linked issues; Tasks become Stories or Tasks. Teams that do not make this decision upfront end up with flat Jira projects that lose the organizational structure that TaskRay Task Groups provided, reducing the usefulness of Jira filters and board views for project managers.

  • Jira has no native checklist object

    TaskRay's Checklist container and granular Checklist Items are first-class child records that preserve sub-task completion states. Jira's base product has no checklist feature — subtasks are full Jira issues, not checklist items. The migration strategy must be chosen during scoping: (1) Jira Subtasks for each Checklist Item, which provides full Jira issue capabilities but multiplies issue count and may hit Jira project issue limits; (2) Linked Issues with Blocks links, which keeps the issue count lower but sacrifices native checklist rendering in the Jira UI. Neither approach preserves the visual Checklist container UI that TaskRay provides natively.

  • TaskRay Templates cannot migrate as Jira Project Templates

    TaskRay Template Projects (Premium feature) allow reusable project skeletons that can be migrated across Salesforce environments. Jira Project Templates serve a comparable function but use a completely different data model. We do not migrate TaskRay Templates as Jira Templates because there is no automated path. We deliver a written template inventory that documents every TaskRay template's structure — Task Group names, Task names, Milestone dates, Dependency chains, and Checklist configurations — so the customer's Jira admin can manually rebuild them using Jira's Quickstart project creation workflow. Starter and Standard editions lack TaskRay's Template Migration feature entirely, so template content is already customer-maintained documentation.

  • Salesforce custom field IDs change at destination

    TaskRay custom fields are Salesforce custom fields with Salesforce-generated field IDs. When migrating TaskRay records through the Salesforce REST API and into Jira, the custom field IDs have no meaning in Jira's schema. We extract the custom field values during export, map them to equivalent Jira custom fields by name, and configure the Jira custom fields in the destination project before import begins. Any custom field validation rules (required formats, conditional requireds, picklist whitelists) configured in Jira must be reviewed and potentially relaxed during migration to avoid rejecting imported records with valid Salesforce-formatted values.

Migration approach

Six steps for a successful TaskRay to Jira data migration

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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

Context on both ends of the pair

TaskRay logo

TaskRay

Source

Strengths

  • Hierarchical project structure (Projects → Task Groups → Tasks → Milestones) accommodates multi-phase implementation and onboarding workflows natively in Salesforce.
  • Templating and cloning capabilities let teams replicate structured project plans at scale without manual re-entry.
  • Field Trickler propagates Account and Opportunity lookups from Project to Task level automatically.
  • Multiple views (Plan/Gantt, Kanban, Spreadsheet, Calendar, My Work) give different team roles their preferred interface without leaving Salesforce.
  • External collaboration via Collaboration Hub lets customers and stakeholders participate in project workspaces without Salesforce licenses.

Weaknesses

  • TaskRay covers only 34% of PMI project management processes, with 0% coverage on cost management, procurement, and risk management — insufficient for revenue-generating professional services.
  • No native billing, invoicing, or expense tracking; organizations requiring these must purchase a separate PSA tool alongside TaskRay.
  • Per-user licensing applies to anyone who views or edits project data, making it expensive at scale for large implementation or CS teams.
  • No public TaskRay API — migrations are entirely dependent on Salesforce REST and Bulk API performance and edition limits.
  • Limited email notification customization for task assignment alerts frustrates teams with specific communication workflow requirements.
Jira logo

Jira

Destination

Strengths

  • Deeply customizable workflows and status schemes with no hard limits on workflow complexity or number of custom statuses.
  • Strong agile ceremony support: sprint planning, backlog grooming, velocity tracking, and burndown charts for Scrum teams.
  • Industry-standard developer tool with native Git integration linking commits, pull requests, and deployments to issues.
  • Large Atlassian Marketplace with thousands of plugins extending time tracking, portfolio management, and reporting capabilities.
  • Free tier available for up to 10 users with unlimited issues, enabling evaluation before committing to a paid plan.

Weaknesses

  • Excessive configurability creates a steep learning curve; cross-team consistency is hard to maintain without strict governance.
  • Performance degrades with large backlogs, complex custom fields, and heavily nested issue hierarchies.
  • Reporting requires additional configuration or paid plugins; out-of-the-box analytics are limited for business users.
  • Jira lacks native sprint management, requiring Jira Software for true agile team features.
  • Teams outside engineering resist adoption due to UI complexity, leaving the all-in-one promise unfulfilled for cross-functional organizations.

Complexity grading

How hard is this migration?

Standard Project Management migration. 3 of 8 objects need a mapping; the rest are 1:1.

B

Overall complexity

Standard migration

Derived from compatibility, mapping clarity, API constraints, and data volume across TaskRay and Jira.

  • Object compatibility

    B

    3 of 8 objects need a mapping; the rest are 1:1.

  • Field mapping clarity

    C

    Field mapping is derived from defaults — final spec confirmed during the sample migration.

  • Timeline complexity

    B

    8-object category — typical timelines run 2–7 days end-to-end.

  • API constraints

    B

    TaskRay: Not documented for TaskRay specifically — governed by Salesforce API limits (edition-dependent, 1,000–unlimited daily calls).

  • Data volume sensitivity

    A

    TaskRay exposes a bulk API — large-volume migrations stream efficiently.

Estimator

Estimate your TaskRay to Jira migration cost

Rule-based pricing — no per-record fees, no manual quotes. Migrations over 2M records are scoped individually.

Step 1

What are you migrating?

Pick a category, then your source and destination platforms.

Category

FAQ

Frequently asked questions about TaskRay to Jira data migrations

Answers to the questions buyers ask most during TaskRay to Jira migration scoping. Not seeing yours? Book a call.

Can't find your answer?

Walk through your TaskRay to Jira migration with a real engineer — 30 minutes, free, written quote within 24 hours.

Book a free 30 minute consultation

Most migrations land between three and five weeks for organizations with fewer than 5 Jira projects and 2,000 Tasks with straightforward hierarchy mapping. Migrations with deep TaskRay hierarchies (Sub-Projects nested under Task Groups), large checklist item volumes (over 10,000 Checklist Items), Jira workflow and issue-type configuration requirements, or multi-environment Jira configurations (staging and production) move to eight to twelve weeks. Timeline depends heavily on the hierarchy mapping decision made during scoping — late changes to the Jira structure after import begins require reimport.

Adjacent paths

Related migrations to explore

Ready when you are

Move from TaskRay.
Land in Jira, intact.

Tell us record counts and timeline. We'll come back with a written quote inside 1 business day — no commitment, no sales pitch.

Accuracy guarantee Rollback included Quote in 1 business day