Project Management migration
Field-level mapping, validation, and rollback between TaskRay and Asana. We move data and schema; workflows are rebuilt natively in Asana.
TaskRay
Source
Asana
Destination
Compatibility
11 of 14
objects map 1:1 between TaskRay and Asana.
Complexity
BStandard
Timeline
3-5 weeks
Overview
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.
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 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
Asana
Project
1:1TaskRay 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
Asana
Project (nested within parent Project) or Section
1:manyTaskRay 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
Asana
Section
1:1TaskRay 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
Asana
Task
1:1The 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)
Asana
Milestone
1:1TaskRay 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
Asana
Subtasks
1:1TaskRay 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)
Asana
Task Dependencies
1:1TaskRay 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)
Asana
Attachments on Task
1:1TaskRay 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)
Asana
Custom Fields
lossyTaskRay 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)
Asana
Project Members (Assignees)
1:1TaskRay 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)
Asana
Custom Fields
1:1TaskRay 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
Asana
Project Templates (Asana)
1:1TaskRay 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)
Asana
Custom Fields or Time Tracking integration
1:1TaskRay'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)
Asana
Not applicable
lossyTaskRay'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.
| TaskRay | Asana | Compatibility | |
|---|---|---|---|
| TaskRay__Project__c | Project1:1 | Fully supported | |
| Sub-Project | Project (nested within parent Project) or Section1:many | Fully supported | |
| TaskRay__TaskGroup__c | Section1:1 | Fully supported | |
| TaskRay__Task__c | Task1:1 | Fully supported | |
| Milestone (Task record type) | Milestone1:1 | Fully supported | |
| Checklist and Checklist Item | Subtasks1:1 | Fully supported | |
| Task Dependency (predecessor/successor links) | Task Dependencies1:1 | Fully supported | |
| Files and Attachments (ContentDocumentLink) | Attachments on Task1:1 | Fully supported | |
| Custom Fields (Project and Task level) | Custom Fieldslossy | Mapping required | |
| Resources (Users and Roles) | Project Members (Assignees)1:1 | Fully supported | |
| Resource Capacity and Utilization (Premium only) | Custom Fields1:1 | Mapping required | |
| Project Templates and Template Builder | Project Templates (Asana)1:1 | Fully supported | |
| Time Tracking entries (Standard tier) | Custom Fields or Time Tracking integration1:1 | Fully supported | |
| Field Trickler lookups (Account and Opportunity) | Not applicablelossy | 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
Asana gotchas
Automation rules have no export representation
API rate limits cap bulk migration throughput
Portfolios are view-only objects that do not hold data
Custom field enum options cannot be updated via API
Subtasks do not appear in project views by default
Pair-specific challenges
Migration approach
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.
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.
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.
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.
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.
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
TaskRay
Source
Strengths
Weaknesses
Asana
Destination
Strengths
Weaknesses
Complexity grading
Standard Project Management migration. 2 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 Asana.
Object compatibility
2 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 Asana migration scoping. Not seeing yours? Book a call.
Walk through your TaskRay to Asana 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 Asana
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.