Project Management migration
Field-level mapping, validation, and rollback between ]project-open[ and Asana. We move data and schema; workflows are rebuilt natively in Asana.
]project-open[
Source
Asana
Destination
Compatibility
5 of 12
objects map 1:1 between ]project-open[ and Asana.
Complexity
BStandard
Timeline
4-8 weeks
Overview
Migrating from ]project-open[ to Asana means moving from an open-source PostgreSQL-backed ERP-PM hybrid to a cloud-native REST-API-first project management platform. The architectural shift is substantial: ]project-open[ stores every entity in a single PostgreSQL database with acs_objects inheritance and acs_rels join tables, while Asana exposes a clean task-centric REST API organized around Projects, Tasks, Sections, and Teams. We handle the extraction side by connecting directly to the PostgreSQL backend using read-only credentials, resolving acs_rels parent-child hierarchies, and normalizing the 't'/'f' boolean character fields. We handle the load side through the Asana REST API with batch chunking and rate-limit backoff. The most significant gap is financial data: ]project-open[ tracks Costs, Invoices, and Timesheets as first-class objects, while Asana stores financial metadata only as custom fields attached to tasks. We document the financial mapping and deliver it as structured custom field definitions for your admin to activate post-migration.
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 ]project-open[ 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.
]project-open[
Project
Asana
Project
1:1Projects in ]project-open[ are the central acs_objects entity keyed by project_id with status governed by object_status_id. We preserve the full project hierarchy by traversing acs_rels to resolve parent-child project assignments, then map each distinct hierarchy level to a separate Asana Project. Project status (potential, active, closed) maps to a custom status field in Asana since Asana Projects do not have a native status property beyond archiving. The project_name becomes the Asana Project name and description maps directly.
]project-open[
Task / Sub-task
Asana
Task
1:1Tasks in ]project-open[ are stored as separate task_id records referencing the project tree with parent-child nesting. We traverse the task hierarchy and flatten sub-tasks into Asana Subtasks linked to the parent Task via the parent_id reference. Task assignment, priority, and due date map to assignee, Custom Field priority enum, and due_on respectively. Any ]project-open[ Task custom attributes are discovered during the pre-migration attribute pass and mapped to Asana custom fields before import.
]project-open[
Company
Asana
Team + Custom Field
1:1Companies in ]project-open[ are im_companies objects with company_name, company_status_id, and type classification stored via object_type_id. Asana has no native company or account object. We map company records to Asana Teams (one Team per company) using company_name as the Team name, with company status and type stored as custom fields on the Team or as custom fields on the Projects where that company is relevant. Customer admin reviews and approves the company-to-team mapping strategy during scoping.
]project-open[
Ticket (im_tickets)
Asana
Task + Custom Fields
lossyTickets in ]project-open[ use im_tickets with ticket_status_id and ticket_type_id integer keys, plus threaded message history via associated tables. Asana has no dedicated ticket object. We map each ticket to an Asana Task with a ticket_type custom field (single-select enum matching the ]project-open[ ticket_type_id labels), a ticket_status custom field, and assignee from the ticket owner. The conversation thread migrates as Task comments in chronological order. If Service Cloud is active in the destination environment, Case is a better fit and we adjust the mapping accordingly.
]project-open[
Cost / Invoice (im_costs)
Asana
Custom Fields on Task
lossyFinancial records in ]project-open[ live in im_costs with variable_cost_p as a boolean 't'/'f' char field, plus amount, cost_type, and billing_status columns. Asana has no native financial or invoicing object. We map cost and invoice data as custom fields on the Asana Task that represents the corresponding work package: cost_amount (number), cost_type (enum), billable (boolean), and invoice_status (enum). The customer configures these custom fields on the relevant Projects during scoping. Actual invoice PDFs from ]project-open[ are not migratable as standalone records and are delivered as a file inventory for manual re-upload.
]project-open[
Timesheet Entry
Asana
Task + Custom Fields
lossyTimesheet hours in ]project-open[ are stored as cost entries linked to users and projects, with date, billing type, and hours logged. Asana has no native timesheet object; the Timesheets feature in Asana is a paid feature that tracks time entries without financial cost modeling. We map timesheet data as custom fields on Tasks (hours_logged, timesheet_date, billing_type) and preserve the user-to-project linkage as task assignees. Asana's native time tracking can be enabled if the customer wants time logged within Asana post-migration, but the historical cost values from ]project-open[ are preserved only as metadata.
]project-open[
User
Asana
User / Member
1:1Users in ]project-open[ are stored across acs_objects and application-specific tables with permissions and group memberships via acs_rels privilege hierarchies. We map user_id, names, and email to Asana Members by email match. The customer's admin provisions Asana user accounts before migration. We flag any ]project-open[ permission or role that has no direct Asana equivalent (OpenACS privilege hierarchies vs Team Member/Admin/Guest roles) in the reconciliation report for admin review. Inactive users are imported as Asana guests if historical assignment records must be preserved.
]project-open[
Custom Fields (dynamic attributes)
Asana
Custom Fields
lossy]project-open[ allows unrestricted dynamic custom attributes per Business Object stored beyond the standard schema columns. These are discovered only by querying the dynamic attribute storage for each object type. We run a full attribute discovery pass against all target object types before designing the mapping specification. Each discovered custom attribute is typed (text, number, date, boolean, enum) and recreated as an Asana custom field. Any formulas, cross-object validations, or computed defaults in ]project-open[ do not migrate — we note them in the handoff document for the admin to implement as Rules or custom fields post-migration.
]project-open[
Office / Location
Asana
Custom Fields
lossyOffices in ]project-open[ store physical location data and link to companies and projects via acs_rels. Asana has no native location entity. We preserve office name, address, and timezone as text or enum custom fields on the relevant Projects or Teams. The customer decides during scoping whether location is stored per-project or per-team based on their reporting structure.
]project-open[
Category / Classification
Asana
Custom Field (enum) or Tag
lossyCategories in ]project-open[ are stored in a hierarchical category system used to classify objects across ticket types, project sectors, cost types, and more. Each category tree has integer category_id values that map to string labels. We resolve all category_id references to their string labels during transformation, then create Asana custom fields of enum type (single-select or multi-select depending on the category usage) with options matching the source labels. Parent-child category hierarchies in ]project-open[ flatten to a flat option list in Asana since Asana does not support hierarchical custom field options.
]project-open[
Document / Attachment
Asana
Attachment / Link
1:1Documents in ]project-open[ are stored as separate objects with references in acs_objects; binary files may be in the filesystem or database depending on configuration. We identify file storage locations during discovery, extract file references, and migrate document URLs as Asana Task Attachments or as Link fields pointing to the original document repository. Binary file migration requires customer approval and may involve file transfer logistics beyond the standard migration scope.
]project-open[
Configuration Item
Asana
Custom Fields on Task
lossyConfiguration items in ]project-open[ track IT assets and their relationships as typed Business Objects with custom attributes. Asana has no native CI or asset management object. We map CI type, key attributes, and any dependency relationships as custom fields on the relevant Task, along with a CI identifier field for reference. The full dependency graph from ]project-open[ is documented separately as a written inventory for the customer's IT team to implement in a dedicated CMDB or asset management tool if required.
| ]project-open[ | Asana | Compatibility | |
|---|---|---|---|
| Project | Project1:1 | Fully supported | |
| Task / Sub-task | Task1:1 | Fully supported | |
| Company | Team + Custom Field1:1 | Fully supported | |
| Ticket (im_tickets) | Task + Custom Fieldslossy | Fully supported | |
| Cost / Invoice (im_costs) | Custom Fields on Tasklossy | Fully supported | |
| Timesheet Entry | Task + Custom Fieldslossy | Fully supported | |
| User | User / Member1:1 | Fully supported | |
| Custom Fields (dynamic attributes) | Custom Fieldslossy | Mapping required | |
| Office / Location | Custom Fieldslossy | Mapping required | |
| Category / Classification | Custom Field (enum) or Taglossy | Fully supported | |
| Document / Attachment | Attachment / Link1:1 | Fully supported | |
| Configuration Item | Custom Fields on Tasklossy | 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.
]project-open[ gotchas
No public API forces direct PostgreSQL database access
Boolean fields use 't'/'f' char values not native booleans
Complex acs_objects inheritance and acs_rels traversal
Custom fields require pre-migration field discovery and mapping
Date and datetime storage formats vary across modules
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 infrastructure access
We audit the source ]project-open[ PostgreSQL database to catalog all active modules (project management, CRM, ticketing, financials, timesheets), project hierarchy depth, user count, custom dynamic attributes per object type, and any legacy or inactive data partitions. We require the customer to provision read-only database credentials and network access to the PostgreSQL server. In parallel, we confirm the target Asana workspace structure: Teams, Project templates, and existing custom field library. The discovery output is a written migration scope document with object counts, a preliminary mapping draft, and a list of infrastructure access requirements for the customer to fulfill.
Schema design and custom field provisioning
We design the Asana destination schema before any data moves. This includes creating the Teams that correspond to the most important ]project-open[ company or organizational unit groupings, provisioning Projects from the source project hierarchy (with flattening strategy documented and approved), and creating custom fields for financial metadata (cost_amount, cost_type, billable, invoice_status), ticket metadata (ticket_type, ticket_status), timesheet data (hours_logged), and any discovered dynamic attributes from ]project-open[. Custom fields are typed (number, date, enum, multi-enum, boolean) to match the source data format. Schema is validated in an Asana Sandbox or test workspace before production provisioning.
Database extraction and transformation
We execute SQL queries against the ]project-open[ PostgreSQL database to extract all target objects. For each object type we join against acs_objects to capture creation dates, modification dates, and object status; we traverse acs_rels to resolve parent-child relationships for projects, user-project assignments, and company-contact links; we apply explicit CASE conversion for all '_p' boolean char fields ('t' -> true, 'f' -> false); we resolve category_id integer keys to their string labels from the category hierarchy; we normalize all datetime values to UTC and log the source format for each field; and we run the custom attribute discovery pass to capture every dynamic attribute across all object types. The extraction runs with read-only credentials only.
Sandbox validation and reconciliation
We load the transformed dataset into a pre-production Asana workspace using the Asana REST API. We validate record counts per object type, spot-check 25-50 records for field-level accuracy against the source database, verify that project hierarchy flattening produces an intelligible structure, and confirm that custom field values land in the correct fields with correct types. The customer reviews the sandbox output and signs off before production migration begins. Any mapping corrections happen at this stage.
Production migration via Asana REST API
We run production migration in dependency order: Teams and Project structure first, then Projects with hierarchy flattened and parent references resolved, then Tasks with subtask nesting and assignee resolution, then Tickets mapped to Tasks with conversation threads as comments, then financial and timesheet metadata as custom field values, then custom dynamic attributes as custom field values. We use the Asana REST API with batch chunking and exponential backoff on rate-limit responses (1,500 requests per minute for Bulk API; 90 requests per minute for standard REST API). Each phase emits a row-count reconciliation report before the next phase begins.
Cutover, delta sync, and handoff documentation
We freeze writes to the source system during the cutover window, run a final delta migration for any records modified during the migration window, then enable Asana as the system of record. We deliver the Workflow and Automation inventory document (covering any Rules or automation patterns visible in the source) and the Financial Field Mapping document specifying every cost, invoice, and timesheet attribute mapped and every attribute that could not be mapped. We support a one-week hypercare window for reconciliation issues raised by the customer team. We do not rebuild automations or workflows as Asana Rules inside the migration scope; that is documented separately for the customer's admin.
Platform deep dives
]project-open[
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 ]project-open[ 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
]project-open[: Not applicable — no public API.
Data volume sensitivity
]project-open[ doesn't expose a bulk API — REST + parallelization used for high-volume runs.
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 ]project-open[ to Asana migration scoping. Not seeing yours? Book a call.
Walk through your ]project-open[ 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 ]project-open[
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.