Project Management migration
Field-level mapping, validation, and rollback between Stackby and Asana. We move data and schema; workflows are rebuilt natively in Asana.
Stackby
Source
Asana
Destination
Compatibility
12 of 16
objects map 1:1 between Stackby and Asana.
Complexity
BStandard
Timeline
4-6 weeks
Overview
Moving from Stackby to Asana is a schema translation, not a direct record copy. Stackby's relational database model (Organizations, Stacks, Tables, Rows, 25-plus column types) must be flattened into Asana's hierarchical task model (Workspaces, Teams, Projects, Tasks, custom fields). A Stackby Stack with multiple Tables maps to an Asana Project with Sections, where each Table becomes one or more Sections. Rows from each Table map to Tasks, with Stackby's column types — text, number, date, select, multi-select, attachment — mapped to Asana custom fields of the equivalent type. Stackby's API rate limit of 5 requests per second per Stack constrains extraction speed and must be accounted for in the migration timeline. Formula columns transfer as computed static values only; live formula recalculation is not preserved. Stackby automations, API connectors, and integrations do not migrate; we deliver a written inventory for the customer's admin to rebuild. Asana's 100MB attachment ceiling via API requires pre-migration audit of any files exceeding that threshold.
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 Stackby 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.
Stackby
Organization
Asana
Workspace
1:1Stackby's Organization (top-level container) maps directly to an Asana Workspace. The Organization name and domain settings transfer as the Workspace name and settings. User accounts and permissions assigned at the Organization level in Stackby map to Workspace membership in Asana, with roles reconciled during the discovery phase. If the customer operates multiple Asana Workspaces, we scope the migration to the target Workspace specified during discovery.
Stackby
Stack
Asana
Project
1:1A Stackby Stack is the organizational unit containing one or more Tables. It maps to an Asana Project, which serves as the container for Tasks. Stack-level settings (visibility, sharing) require manual configuration in Asana because Project-level visibility settings differ from Stack sharing rules. We recommend the customer review Asana's project privacy settings (public to workspace, private, or shared) against the original Stack sharing configuration during discovery.
Stackby
Table
Asana
Section or Project split
1:manyA Stackby Table within a Stack maps to an Asana Section within the corresponding Project. If the Stackby Table contains more than 500 Rows and the customer wants separate task groupings, we can split one Table into multiple Asana Projects (each becoming a separate project with its own Sections). Column definitions from the Stackby Table schema are translated to Asana custom fields on the Project; the Section name reflects the original Table name. Lookup columns referencing other Tables generate a text or ID custom field in Asana (no native cross-project lookup in Asana); the customer's admin may implement a third-party lookup solution post-migration.
Stackby
Row
Asana
Task
1:1Each Stackby Row maps to an Asana Task within the corresponding Section. The Row's primary text fields (Name, Description) map to Task Name and Task Description (rich text). Column values map to custom field values on the Task. Row timestamps (Created At, Updated At) transfer as custom fields or task creation metadata; Asana does not support custom created-at timestamps, so the original timestamp is stored in a custom field for audit purposes. Completed-row status in Stackby maps to Task completion in Asana.
Stackby
Column: Text and Long Text
Asana
Custom Field: Text
1:1Stackby Text and Long Text columns map to Asana Text custom fields. Character limits in Stackby columns are not enforced in Asana; we note any character limits in the field notes so the customer's admin can add validation if needed. Rich text formatting in Stackby Long Text columns (if used) is preserved as HTML in the task description but may require manual reformatting after migration.
Stackby
Column: Number and Currency
Asana
Custom Field: Number
1:1Stackby Number and Currency columns map to Asana Number custom fields. Currency columns retain the numeric value; currency symbol and formatting do not transfer and must be reconfigured in Asana's field settings. Decimal place settings from Stackby are noted for the customer's admin to set in Asana.
Stackby
Column: Date and DateTime
Asana
Custom Field: Due Date or Start Date
1:1Stackby Date columns map to Asana Due Date or Start Date custom fields depending on the column's semantic role (deadline vs start). DateTime columns with time-of-day precision map to a custom field in Asana since Asana's native Due Date does not store time. Time zone handling is documented during discovery; UTC normalization may be required if the source and destination time zones differ.
Stackby
Column: Select (Single Select)
Asana
Custom Field: Enum (Drop-down)
1:1Stackby Select columns map to Asana Enum custom fields (drop-down). The picklist values transfer as the enum options. We validate that enum option names do not exceed Asana's 255-character limit. Option color coding from Stackby is not preserved in Asana (Asana supports limited color customization per enum value but not at the level of Stackby's color picker).
Stackby
Column: Multi-select
Asana
Custom Field: Multi-select Enum
1:1Stackby Multi-select columns map to Asana Multi-select Enum custom fields. Multiple selected values transfer as multiple entries in the Asana multi-select field. Asana supports multi-select from the Premium tier onward; if the destination Workspace is on Asana Basic, we flag this as a tier upgrade requirement during discovery.
Stackby
Column: Attachment
Asana
Task Attachment
1:1Stackby attachment columns map to Asana task attachments. Files are downloaded from Stackby via API and uploaded to Asana via the Asana Attachments API. Asana enforces a 100MB per-file limit for API-attached files; files exceeding this threshold are flagged and either skipped (with a written list for manual re-upload to Google Drive or Dropbox and link-sharing) or handled via Asana's external link attachment type. We audit total attachment volume during discovery to scope this phase.
Stackby
Column: Formula
Asana
Custom Field: Number or Text (static value)
lossyFormula columns in Stackby (cross-column calculations, aggregations, conditional logic) are computed dynamically and cannot be expressed as live formulas in Asana. During migration, formula columns transfer as their computed value at migration time, stored as a Number or Text custom field in Asana. We flag every formula column during discovery with its original formula expression so the customer's admin can manually rebuild logic in Asana Rules (if computational) or external tools (if complex). The static value note is critical — the field will not update if source data changes after migration.
Stackby
Column: Link or URL
Asana
Custom Field: Text or External Link
1:1Stackby Link or URL columns map to Asana Text custom fields storing the URL string. Asana's native External Link field type is limited to specific integrations; we use Text for broad compatibility. Hyperlink formatting from Stackby is preserved as a raw URL string.
Stackby
Column: Checkbox
Asana
Custom Field: Checkbox
1:1Stackby Checkbox columns map to Asana Checkbox custom fields. Boolean true/false transfers directly. Asana supports checkbox custom fields from Premium onward; we verify destination tier during discovery.
Stackby
View: Kanban
Asana
Asana Board view
lossyStackby Kanban views (grouped by a Select column) map to Asana's Board view on the corresponding Project. The grouping column in Stackby (e.g., Status) maps to the Board column field in Asana. We recreate the Board configuration using the same column groupings. Note that Stackby's multi-column Kanban (grouped by multiple dimensions simultaneously) cannot be replicated in Asana's single-dimension Board; we map the primary grouping and document secondary groupings in the handoff notes.
Stackby
View: Calendar
Asana
Asana Calendar view
lossyStackby Calendar views (based on a Date column) map to Asana's Calendar view on the Project. The date field used for calendar rendering transfers as the Calendar view's date dimension. Stackby's event color-coding by column value is noted but not replicated in Asana Calendar (which supports limited color options).
Stackby
Form
Asana
Not migrated
1:1Stackby Forms (for data entry) are configuration constructs that collect responses and write to linked Tables. We migrate the Form's field structure and the resulting Rows (which are already captured as Table rows) but the Form itself cannot be replicated in Asana because Asana does not have a native form builder for task creation from external respondents. We document the Form schema (field names, types, validation rules) in the handoff package so the customer can rebuild using Asana's intake forms (Business tier), Google Forms, or a third-party form tool like Typeform or Jotform with an Asana integration.
| Stackby | Asana | Compatibility | |
|---|---|---|---|
| Organization | Workspace1:1 | Fully supported | |
| Stack | Project1:1 | Fully supported | |
| Table | Section or Project split1:many | Fully supported | |
| Row | Task1:1 | Fully supported | |
| Column: Text and Long Text | Custom Field: Text1:1 | Fully supported | |
| Column: Number and Currency | Custom Field: Number1:1 | Fully supported | |
| Column: Date and DateTime | Custom Field: Due Date or Start Date1:1 | Fully supported | |
| Column: Select (Single Select) | Custom Field: Enum (Drop-down)1:1 | Fully supported | |
| Column: Multi-select | Custom Field: Multi-select Enum1:1 | Fully supported | |
| Column: Attachment | Task Attachment1:1 | Fully supported | |
| Column: Formula | Custom Field: Number or Text (static value)lossy | Fully supported | |
| Column: Link or URL | Custom Field: Text or External Link1:1 | Fully supported | |
| Column: Checkbox | Custom Field: Checkbox1:1 | Fully supported | |
| View: Kanban | Asana Board viewlossy | Fully supported | |
| View: Calendar | Asana Calendar viewlossy | Fully supported | |
| Form | Not migrated1: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.
Stackby gotchas
API rate limit of 5 req/s per stack blocks bulk migration
Plan-tier row limits can silently truncate data
Automations and integrations do not migrate — only data does
Formula columns become static values at migration time
Attachment storage limits vary by plan and must be verified
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 Stack inventory
We audit every Stackby Stack in the source organization. This includes counting Stacks, Tables per Stack, Row counts per Table, column types per Table, formula columns, attachment file sizes, cross-table lookup columns, active automations, and API connector configurations. We also identify the destination Asana Workspace, verify its tier (Basic, Premium, Business) to confirm custom field support, and count the target user seats. The discovery output is a written migration scope document listing every object to migrate, every column type to map, every formula to flag, every attachment to audit for size, and the estimated timeline based on API rate-limit pacing.
Schema mapping design
We design the destination Asana schema based on the discovery inventory. Each Stackby Stack maps to an Asana Project. Each Table maps to a Section (or multiple Sections if row count warrants splitting). Each Column type maps to an Asana custom field type (Text, Number, Enum, Multi-enum, Date, Checkbox). We pre-create all custom fields in the destination Asana Workspace via API before any data migration begins, so the field IDs are available for task inserts. Cross-table lookup columns are documented as text custom fields with a note on manual re-linking post-migration. We coordinate with the customer on Asana tier requirements if Premium is needed for custom field support.
Attachment pre-audit and external file preparation
We run an attachment audit across all Stackby Tables. Every file is sized; files under 100MB are queued for direct API migration. Files over 100MB are flagged with their Stackby download URLs in a written inventory. The customer decides whether to re-upload to Google Drive or Dropbox and share as URL attachments, or accept that those files will be migrated as external links pointing to the Stackby-hosted originals (which may become inaccessible after the source account is deactivated). This step resolves the Asana 100MB API ceiling before the production migration run.
Sandbox migration and reconciliation
We run a full migration into a test Asana Workspace using the customer's data at representative volume. We migrate all Stacks, Tables, Rows, column data, and attachments under 100MB, then pause for the customer's team to reconcile. The customer spot-checks 25-50 random Tasks across Projects against the Stackby source, verifies custom field values, confirms attachment presence, and reviews the formula column static values. Any mapping corrections (wrong column-to-field type, missing fields, incorrect enum values) are documented and fixed before production migration begins. We do not proceed to production until the customer signs off on the sandbox reconciliation report.
Production migration with rate-limit pacing
We run production migration in dependency order: first Projects (Stacks), then Sections (Tables), then Tasks (Rows with custom field values). Stackby's 5 req/s per Stack limit is enforced with request pacing and exponential backoff on 429 responses. We migrate attachments in parallel with task migration, skipping files over 100MB and substituting external link attachments per the pre-audit inventory. Formula columns are inserted as their computed static values. Each phase emits a row-count reconciliation report. If any records fail due to Asana validation rules or field-type mismatches, we log them to a retry queue, adjust the mapping, and re-run the failed batch before closing the phase.
Cutover and automation rebuild handoff
We freeze Stackby write access during the cutover window, run a final delta migration of any records created or modified during the migration run, then mark Asana as the system of record. We deliver the Automation and Integration Inventory document listing every Stackby automation trigger-action pair, every API connector configuration, and every Form schema with recommended Asana Rules equivalents (or third-party tools where Asana Rules cannot replicate the behavior). We provide a one-week hypercare window for reconciliation issues. We do not rebuild automations, connectors, or forms as part of the migration scope; those are separate engagements or internal admin tasks.
Platform deep dives
Stackby
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 Stackby 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
Stackby: 5 requests per second per Stack (429 response + 30-second backoff on exceedance).
Data volume sensitivity
Stackby 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 Stackby to Asana migration scoping. Not seeing yours? Book a call.
Walk through your Stackby 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 Stackby
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.