Project Management migration

Migrate from TaskRay to Asana

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

TaskRay logo

TaskRay

Source

Asana

Destination

Asana logo

Compatibility

79%

11 of 14

objects map 1:1 between TaskRay and Asana.

Complexity

BStandard

Timeline

3-5 weeks

Rollback included Accuracy guarantee Field-level validation

Overview

What this migration involves

Moving from TaskRay to Asana is a cross-platform structural migration. TaskRay stores all project data as Salesforce native objects — TaskRay__Project__c, TaskRay__TaskGroup__c, TaskRay__Task__c, and TaskRay__Milestone__c — meaning every export runs through Salesforce's API, not a TaskRay API (none exists). We read from Salesforce REST or Bulk API 2.0, transform the hierarchical structure into Asana's Workspace-Team-Project-Section-Task model, and write via the Asana REST API with batch chunking and dependency resolution. Milestones, checklists, subtasks, dependencies, attachments, and custom fields all migrate. Field Trickler lookups to Salesforce Account and Opportunity require manual re-link post-import because those IDs do not exist in Asana. Resource capacity, utilization, Dynamic Team Builder, and time tracking records migrate as custom fields only — the actual capacity graph and resource planner do not transfer. Workflows, templates-as-code, and Collaboration Hub settings do not migrate; we deliver a written inventory for admin rebuild in Asana's native automation tools.

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

Asana logo

Asana

What's pulling them in

  • Organizations with distributed teams cite Asana's multiple project views (List, Board, Calendar, Timeline) as the primary reason for adoption, allowing each team member to work in their preferred interface without changing the underlying data.
  • The platform's 100+ native integrations with tools like Slack, Google Drive, Salesforce, and Microsoft Teams reduce context-switching and keep work synchronized across the stack.
  • Small teams and non-profits value the free plan's generous limits: unlimited projects and tasks for up to 15 team members with basic views, enabling teams to validate fit before committing to a paid tier.
  • Marketing and creative teams specifically praise Asana's visual project organization, reporting dashboards, and timeline views for managing cross-functional campaign workflows.
  • Project managers report that Asana's dependency management and workload views help surface bottlenecks before they derail deadlines.

Object mapping

How TaskRay objects map to Asana

Each row shows how a TaskRay object lands in Asana, 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__c

maps to

Asana

Project

1:1
Fully supported

TaskRay Projects map directly to Asana Projects. Each Project in TaskRay carries a name, description, status, start date, target end date, custom fields, and file attachments. We export via Salesforce REST API, map dates to Asana's due_date and start_date fields on the Project, and create the Project in Asana before importing any child records. TaskRay project-level Chatter threads do not migrate; we flag thread content as a written attachment inventory for manual re-posting if the conversations contain action items.

TaskRay

Sub-Project

maps to

Asana

Project (nested within parent Project) or Section

1:many
Fully supported

TaskRay Sub-Projects are child records of Projects and can contain their own Task Groups and Tasks. When the source hierarchy is two levels deep, we create a corresponding Asana Project and nest it inside the parent Project using Asana's section or subgroup structure. When Sub-Projects exceed the two-level depth limit in TaskRay, we flatten deeper children at export time and warn the customer that original nesting depth will be reduced. Asana does not support multi-level project nesting beyond one level of sections, so deeply nested TaskRay structures require a flattening strategy agreed upon during scoping.

TaskRay

TaskRay__TaskGroup__c

maps to

Asana

Section

1:1
Fully supported

TaskRay Task Groups represent phases or thematic groupings within a Project and map cleanly to Asana Sections. We preserve the TaskGroup-to-Project parent linkage by creating Sections inside the corresponding Asana Project before importing child Tasks. Task Group descriptions migrate as Section descriptions in Asana. Custom fields on TaskGroup records migrate as custom fields on the Section, though Asana Sections do not natively support custom fields — these attach to the first Task in the Section or become project-level custom fields per customer preference.

TaskRay

TaskRay__Task__c

maps to

Asana

Task

1:1
Fully supported

The core work unit maps directly to Asana Task. We preserve task name, description (rich text), due date, start date, assignee, blocked and locked states (via custom fields), repeating flags (as custom fields or Notes), and predecessor links. Checklist containers migrate separately as subtasks. Custom fields on TaskRay Task objects map to Asana custom fields, which must be pre-created in the destination project because Asana enforces a project-level custom field model. Status mapping depends on the TaskRay status field values and the Asana workflow chosen during scoping.

TaskRay

Milestone (Task record type)

maps to

Asana

Milestone

1:1
Fully supported

TaskRay Milestones are a distinct Task record type rendered as diamond icons in Plan View. They map to Asana Milestones directly. The milestone date migrates as the Task due date with the milestone flag set to true. We identify Milestones separately during extraction using the TaskRay milestone flag field and import them after all regular Tasks to avoid dangling dependencies. TaskRay milestones with checklist sub-items require those sub-items to migrate as regular Tasks under the milestone, since Asana Milestones cannot contain checklists.

TaskRay

Checklist and Checklist Item

maps to

Asana

Subtasks

1:1
Fully supported

TaskRay Checklist Items map to Asana Subtasks. Each Checklist is a container on a Task; we create a Subtask for every Checklist Item, preserving the completion status (completed/incomplete), name, and notes. The parent Task in Asana holds the Checklist container concept. Subtask completion ordering is preserved from the source Checklist sequence. Asana does not support nested subtasks under a subtask, so deeply nested TaskRay checklists require a flattening step.

TaskRay

Task Dependency (predecessor/successor links)

maps to

Asana

Task Dependencies

1:1
Fully supported

TaskRay task dependencies use predecessor and successor links on the TaskRay Task object. We export these as Asana dependency records using Asana's dependency_type (Finish-to-Start, Start-to-Start, etc.) and the Asana REST API's dependency endpoint. After importing all Tasks, we submit the dependency pairs in a second pass. We validate dependency chains post-import to flag any dangling predecessor links caused by tasks that were flattened or not migrated. Note: Asana has documented dependency date-shift bugs in complex timeline configurations — we warn customers and suggest validating dependency chains manually post-migration.

TaskRay

Files and Attachments (ContentDocumentLink)

maps to

Asana

Attachments on Task

1:1
Fully supported

TaskRay stores files on the Salesforce ContentDocumentLink model. We export files attached to TaskRay records via Salesforce's file APIs and re-attach them to the corresponding Asana Task using the Asana attachments endpoint. File size limit in Asana is 100MB per attachment; files exceeding this limit are flagged for manual upload. We preserve the original file name and link to the task in a migration inventory document.

TaskRay

Custom Fields (Project and Task level)

maps to

Asana

Custom Fields

lossy
Mapping required

TaskRay custom fields on Project and Task objects are Salesforce custom fields accessible via the REST API. We detect all custom fields during discovery, classify them by data type (text, number, date, picklist, checkbox, lookup), and create corresponding custom fields in each destination Asana project before data import. Asana custom fields are project-scoped (local) or organization-scoped (global) — we recommend global fields for fields used across multiple projects. Picklist values in TaskRay map to Asana enum options, and multi-select picklists map to Asana multi-enum fields.

TaskRay

Resources (Users and Roles)

maps to

Asana

Project Members (Assignees)

1:1
Fully supported

TaskRay Resources represent individual users who own and complete work; Roles are placeholder owners. We resolve Resources by email match against the Asana workspace members. Any Resource without a matching Asana User is held in a reconciliation queue. TaskRay Role placeholders (non-user job function assignments) are noted in the mapping inventory and must be converted to named Asana users or removed post-migration, since Asana does not have a Role concept as a placeholder assignee.

TaskRay

Resource Capacity and Utilization (Premium only)

maps to

Asana

Custom Fields

1:1
Mapping required

TaskRay capacity data, utilization percentages, and Dynamic Team Builder configuration exist only on the Premium tier and are stored as custom fields or configuration records in Salesforce. We can migrate the numeric capacity and utilization values as custom fields on the corresponding Task or Project in Asana, but the interactive Resource Planner, Capacity heatmap, and Assignment Decision Making tools do not transfer — Asana has no native equivalent. We flag this gap and recommend Asana's portfolio workload view as a partial replacement for capacity visibility.

TaskRay

Project Templates and Template Builder

maps to

Asana

Project Templates (Asana)

1:1
Fully supported

TaskRay Template Projects and the Template Builder feature are migratable as standard Salesforce records, but the Template Migration feature (Premium-only) that copies templates across Salesforce environments does not apply when moving to Asana. We export template Projects as Asana Projects with a template naming convention and flag them as templates in a custom field. The customer recreates the template structure in Asana's own template feature post-migration if needed. Collaboration Hub and Communities configuration do not migrate — these are Salesforce-specific settings with no Asana equivalent.

TaskRay

Time Tracking entries (Standard tier)

maps to

Asana

Custom Fields or Time Tracking integration

1:1
Fully supported

TaskRay's Timer and Timesheet features (Standard tier and above) store time entries on Tasks. We export time entry records as numeric duration values in hours and migrate them as custom fields on the corresponding Asana Task. Asana does not have native time tracking; if the customer requires time logging, we recommend connecting an Asana time tracking integration (Harvest, Toggl, or similar) post-migration and setting the time entry field mapping accordingly.

TaskRay

Field Trickler lookups (Account and Opportunity)

maps to

Asana

Not applicable

lossy
Fully supported

TaskRay's Field Trickler propagates Account and Opportunity lookups from the Project level down to all Tasks automatically. These are Salesforce IDs that have no meaning in Asana. We extract the Trickler target values during export, match them by name to destination Account and Opportunity records (if the customer maintains those in a connected CRM), and store the linked name in a custom field on the Asana Project or Task. The actual Salesforce lookup relationship cannot be preserved without a Salesforce-Asana integration layer, which is outside migration scope.

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

Asana logo

Asana gotchas

High

Automation rules have no export representation

High

API rate limits cap bulk migration throughput

Medium

Portfolios are view-only objects that do not hold data

Medium

Custom field enum options cannot be updated via API

Low

Subtasks do not appear in project views by default

Pair-specific challenges

  • No standalone TaskRay API — all reads run through Salesforce

    TaskRay exposes no independent REST or GraphQL API. Every data export operation 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 daily API calls, Professional allows 115,000, Unlimited and Enterprise have no per-day ceiling. We profile API headroom before migration begins, prefer Bulk API 2.0 for large record volumes to minimize API call counting, and pause migration during any scheduled Salesforce org maintenance windows. Customers with Essentials or low-tier Professional editions may need extended migration timelines due to API quota constraints.

  • TaskRay Salesforce lookups have no Asana equivalent

    TaskRay's Field Trickler links Projects and Tasks to Salesforce Account and Opportunity records via Salesforce IDs. These IDs do not exist in Asana and cannot be imported as live relationships. We extract the lookup targets by name during export, store them in custom fields in Asana, and flag them for manual re-link if the customer intends to maintain a CRM connection. Teams that rely on TaskRay's tight Salesforce CRM integration for pipeline visibility lose that cross-object context when migrating to Asana unless they deploy a separate Salesforce-Asana connector.

  • Task hierarchy flattening required at two levels

    TaskRay supports Projects and Sub-Projects (two-level project hierarchy), with Task Groups and Tasks nested within. Asana Projects contain Sections and Tasks with Subtasks — there is no multi-level project nesting. We flatten deeply nested TaskRay structures during export: deeply nested Sub-Projects become top-level Projects or Sections depending on customer preference, and the original parent-child depth is recorded in a custom field for audit. Asana subtasks do not have their own subtasks, so any Checklist or Task deeper than one level of nesting requires flattening to a flat subtask list under the parent.

  • Asana dependency date-shift bugs in complex chains

    Asana's dependency engine has documented issues with date shifting in complex timeline configurations, particularly when milestones are preceded by multiple tasks or when finish-start dependencies are mixed with start-finish links. TaskRay dependencies migrate correctly as Asana dependency records, but customers with complex multi-path dependency chains should validate date propagation manually after migration and be prepared to manually adjust task dates if Asana produces incorrect cascading shifts. We document this known limitation in the post-migration validation checklist.

  • Custom field pre-creation required in Asana before import

    Asana enforces project-level custom field definition — fields must be created in a project before data can populate them. We create all custom fields before importing any Tasks, but Asana's limit on custom field options per single-select field (100 options) and the organizational overhead of managing local vs global fields requires planning. TaskRay picklists with more than 100 values must be split across fields or truncated during migration, which we surface during the scoping phase.

Migration approach

Six steps for a successful TaskRay to Asana data migration

  1. Discovery and Salesforce API profiling

    We audit the source Salesforce org across TaskRay objects: count of Projects, Sub-Projects, Task Groups, Tasks, Milestones, Checklist Items, dependencies, custom fields (and their data types), ContentDocumentLink attachments, and Resource records. We profile the Salesforce edition's API call quota to confirm whether Bulk API 2.0 is necessary or standard REST API suffices. We identify any custom fields on TaskRay objects that reference Salesforce lookup relationships beyond Account and Opportunity and flag those as non-migratable. The discovery output is a written migration scope, a record-count estimate, and an API headroom recommendation.

  2. Asana workspace and project structure setup

    We create the Asana workspace, Teams, and initial Project structure before any data import. We create organization-level custom fields for fields that will appear across multiple Projects, and project-level custom fields for Project-specific fields. We configure the Asana custom field types to match Salesforce data types (text to text, number to numeric, picklist to enum, multi-select to multi-enum, date to due_date). We configure milestone configuration and dependency settings on each Project. This step requires the customer to provision Asana user accounts so that we can assign tasks during import.

  3. Salesforce data extraction via Bulk API 2.0

    We export TaskRay records from Salesforce in dependency order: Projects first, then Sub-Projects, Task Groups, Tasks, Milestones, Checklist Items, Resources, and Attachments. We use Bulk API 2.0 for large extractions (over 10,000 records) to minimize API call counting. We extract ContentDocumentLink records separately for file attachment migration. Custom field values on each object are included in the extraction. We validate record counts against the discovery estimate and surface any unexpected objects or field types before transformation begins.

  4. Transformation, hierarchy flattening, and mapping

    We transform the extracted Salesforce records into Asana API payload format. This includes: mapping TaskRay status values to Asana task completion states, mapping dates to Asana due_date and start_date fields, resolving Resource email addresses to Asana User GIDs, converting TaskRay dependency pairs to Asana dependency records, and flattening Sub-Project and Checklist nesting to match Asana's single-level constraint. We create a mapping manifest for every custom field linking Salesforce field API names to Asana custom field GIDs. Field Trickler lookup targets are extracted as text values and stored in dedicated custom fields.

  5. Asana import with batch chunking and dependency re-link

    We import data into Asana in record-dependency order: Projects first, then Sections, Tasks, Milestones, and Subtasks. We use Asana's batch POST endpoint with chunk sizes of 100 records per request to stay within Asana's rate limits. After all Tasks are imported, we submit dependency records in a second pass by matching TaskRay predecessor/successor IDs to the newly created Asana task GIDs. We re-attach files to tasks using the Asana attachments endpoint, mapping source ContentDocument IDs to the destination attachment inventory. Each phase emits a row-count reconciliation report.

  6. Cutover, validation, and automation rebuild handoff

    We freeze Salesforce writes on the TaskRay org during cutover, run a final delta migration of any records modified during the migration window, then hand over Asana as the system of record. We deliver a post-migration validation checklist covering record counts, dependency chain integrity, attachment completeness, and custom field population. We deliver a written inventory of TaskRay workflows, templates, Collaboration Hub settings, time tracking entries, and Resource capacity records that require manual rebuild in Asana's automation tools (Rules, Forms) or a third-party integration. We support a five-business-day hypercare window for reconciliation issues.

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.
Asana logo

Asana

Destination

Strengths

  • Unlimited projects and tasks on the free plan for teams up to 15 members.
  • 100+ native integrations including Salesforce, Slack, Google Drive, and Microsoft Teams.
  • Four distinct project views (List, Board, Calendar, Timeline) in a single interface.
  • Dependency management with start/end dates and predecessor links for critical path tracking.
  • Portfolio dashboards for executives to track cross-project status and workload.

Weaknesses

  • Per-seat pricing scales expensively: Advanced tier costs nearly double Starter for a 50-seat team.
  • API does not expose all UI-accessible data; some fields require screen-scraping for full fidelity.
  • Automation rule limits on lower tiers are restrictive, causing power users to upgrade or leave.
  • No native document/wiki capability forces teams to use external tools for knowledge management.
  • Rate limits (150 req/min on free, 1,500 req/min on paid) constrain bulk migration throughput.

Complexity grading

How hard is this migration?

Standard Project Management migration. 2 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 Asana.

  • Object compatibility

    B

    2 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 Asana 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 Asana data migrations

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

Can't find your answer?

Walk through your TaskRay to Asana 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 up to 500 Projects, 10,000 Tasks, and straightforward custom field configurations. Migrations with large attachment volumes, complex multi-path dependency chains, Resource capacity records requiring custom field mapping, or source Salesforce orgs on lower-tier editions (where API quotas constrain throughput) extend to seven to twelve weeks. The Salesforce API edition profiling step adds approximately one week upfront but prevents mid-migration quota exhaustion.

Adjacent paths

Related migrations to explore

Ready when you are

Move from TaskRay.
Land in Asana, 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