Skip to content
Get a quote

Migrate to monday Work Management

monday.com Work Management is a board-based project platform whose import model rewards teams that pre-build the workspace, choose the right column types up front, and respect the platform's bulk-load limits on every job.

Short answer

FlitStack AI migrates projects, tasks, and timelines into monday Work Management from 150+ project management tools, including Notion, Trello, Jira, Slack. Every field is mapped to monday Work Management's objects, history and associations come across, the monday Work Management setup is configured alongside, and the whole migration stays reversible in one click.

By

From Any source
Destinationmonday Work Management
NotionTrelloJiraSlackAirtable
150+ sources mapped into monday Work Management

Systems we move into monday Work Management

The project management tools teams most often move from. Each page shows what moves, the field mapping and what to watch for.

What monday Work Management supports, and where its import tools stop

  • Lowest onboarding friction of any mid-market PM tool — drag-and-drop boards and colorful UI mean non-technical team members contribute from day one without training.
  • Highly customizable board structure lets teams model their actual workflow rather than forcing a predefined template onto their process.
  • Generous free forever plan with two seats lets small teams or solo users validate the platform before committing budget or migrating data from elsewhere.
  • Integrations with Slack, Zoom, Google Drive, and CRM tools keep monday.com as a coordination hub rather than requiring teams to switch context constantly.
Bulk APIOAuth 2.0 (preferred for marketplace apps), personal API tokens, or shortLivedTokens for app embeds. Tokens are scoped per app's authorization scopes.
Rate limitsComplexity-based: 10,000,000 complexity points per minute per account. A per-minute request limit and a per-IP limit of 5,000 requests per 10 seconds also apply. 429 responses include a Retry-After header.
ObjectSupportNote
BoardsfullBoards are the top-level workspace container. Each Board has a name, owner, workspace, and set of Groups. We map Board identity and metadata 1:1. Note that board-level settings like default view and notification preferences are API-readable but may require re-application in the destination.
ItemsfullItems are the primary work unit on a Board — the equivalent of Tasks in standard PM terminology. Every Item has a name, status, assignees, and timestamps. The API returns Items with their column values as key-value pairs. We map Item fields by column ID and preserve status, date, and assignee data in standard normalized format.
GroupsfullGroups are horizontal row containers within a Board, typically representing a status column or phase. Items live inside Groups. We preserve Group order and name, and we map Items into matching Groups in the destination based on Group name or position.
ColumnsmappedColumns are monday.com's field model — there are 20+ column types including Status, Date, Timeline, Numbers, Text, Link, File, Dependency, Formula, and Vote. We dynamically inspect the board's column schema before migration and build a field-mapping table. Not all column types map directly to standard PM fields; formula outputs, vote counts, and location coordinates require custom field handling.
SubitemsmappedSubitems are Items nested beneath a parent Item. They are second-class citizens in monday.com: no bulk export endpoint, no subitem-specific API filter, and no native subitem-to-subitem dependency. We handle Subitems by querying each parent Item and expanding its subitem array, then writing them as flat Items with a parent reference field in the destination.
Users / OwnersfullUsers are the human actors in monday.com — assigned to Items, owning Boards, and invited to Workspaces. We map Users by email and preserve display name. Owner assignment on Items translates to Assignee fields in standard PM systems.
TeamsfullTeams are monday.com's grouping mechanism for users, used for team-based permission scoping and Workload views. We map Teams to their member list and preserve team membership as a group-assignee mapping in the destination.
DependenciesmappedThe Dependency column links Items across Boards or within a Board as predecessor-successor pairs. monday.com's dependency model supports only column-based input (no DAG visualization), and the API returns dependency pairs as an array. We flatten these into explicit predecessor-successor relationship records and write them to the destination's dependency model.
Updates / CommentsmappedUpdates are threaded comments on Items. Each Update carries a body (HTML or plain text), author, timestamp, and optional reply-to ID. The API allows querying updates per Item. We preserve Update text, author, and timestamp. HTML formatting is stripped to plain text unless the destination supports rich-text bodies.
Files / AttachmentsmappedThe File column and inline attachments on Items store file metadata — name, URL, uploader, and timestamp. We preserve file references as URL strings. Actual binary file download is out of scope for most migration scenarios; we flag which Items have attachments so the customer can handle file migration manually or via a separate file-transfer step.
Tags / LabelsfullTags are a Labels column type in monday.com — free-text labels applied to Items. Tags have a name and optional color. We map Tags to the destination's label/tag field by name and preserve the color as a hex value in a custom field if the destination supports it.
Time TrackingmappedTime Tracking is a column type that logs time entries against an Item. monday.com records duration per entry with a description and assignee. The API returns time entries as nested data under the Item. We extract time entries as separate records linked to the parent Item and preserve hours, assignee, and description.
Integrations / AutomationsnoneAutomations (trigger-action rules built with monday.com's Automation Center) and Integrations (third-party connections like Slack, Zoom, Salesforce) are configuration objects that do not export via API in a transferable format. We do not migrate automations or integrations — these must be rebuilt manually in the destination environment.
ViewsnoneViews — Gantt, Calendar, Kanban, Chart, Map, and custom saved views — are display configurations tied to a Board. monday.com does not expose saved view definitions via API. We do not migrate views; users should expect to recreate their preferred view configurations in the destination tool.

The monday Work Management migration guide

Why teams migrate to monday.com

The four shapes a monday.com work-management migration takes, and what makes the platform easier — or harder — than the category average.

monday.com Ltd. (styled in lowercase as monday.com) was founded by Roy Mann, Eran Zinman and Eran Kampf in 2012, launched its platform in 2014, and is headquartered in Tel Aviv, Israel1. The company went public on Nasdaq in June 2021. monday Work Management is the general project-and-process product inside a broader Work OS that also includes monday dev, monday CRM, monday service and monday campaigns, all built on the same underlying mondayDB engine and board model.

The typical monday Work Management customer is a delivery team — 20 to 500 people — that runs cross-functional projects, sprints or repeatable processes and wants Gantt views, dependencies, time tracking and recurring tasks in the same workspace as the documents and Updates that go with them.

Compared with Asana or ClickUp, monday positions on the elasticity of a board model where every project artefact is a customisable board rather than a fixed task list; compared with Jira or Microsoft Project, it positions on a flatter learning curve and a visual Kanban-first delivery view that delivery leads can adopt without an admin function.

The shapes of migration that actually land on monday Work Management tend to fall into four patterns. First, Asana, Trello and ClickUp exits, driven by teams that grew out of a single-list tool and want multi-board structure with dependencies and time tracking baked in. Second, Jira moves, usually a non-engineering function (marketing, operations, PMO) that wants the same workflow rigor without the Jira admin surface area.

Third, spreadsheet and legacy replacements — teams running projects on Excel, Google Sheets, Smartsheet or a homegrown database where the schema is loose and the project is really a re-architecture. Fourth, Microsoft Project and Wrike consolidations, where the parent organisation standardises on monday and pulls smaller-team tooling onto it. Each shape has a different profile: an Asana move has clean object parity but no dependency-column equivalent; a Jira move has rich workflow that does not transfer across at all.

What makes migrating to monday Work Management easier than the category average is the board model itself — every project artefact is a board you can shape exactly to your process, and the native CSV/Excel importer ships under the Add → Import items button on any board with up to 8,000 rows per file10.

What makes it harder than the average is column-type discipline: monday boards do not enforce a schema at the platform level, so the same field on two boards can drift into different types and break Connect Boards and Mirror columns silently46. Pricing is also per-seat across the entire account, billed in tier-stepped seat blocks, so teams that bring in stale users to preserve historical task ownership inflate the seat count and the annual bill.

Automations (recipes), dashboard widgets, time-tracking session history and the Updates thread on each item do not import — they are rebuilt or recreated from documentation. Teams that scope for that work up front finish on time; teams that assume parity do not.

Teams that scope for the rebuild work up front finish on time; teams that assume parity do not.

The monday.com data model you need to map into

Workspaces, boards, groups, items, subitems and the column types that carry your project schema — the destination decoded.

monday Work Management is built around a simple primitive — the board — and everything else composes from it. A workspace contains folders and boards; a board contains groups (which you typically map to a sprint, phase or stage); a group contains items (which map to tasks); items can have subitems (which map to subtasks); and items carry column values plus an Updates thread and a Files column for attachments80.

Before you can map a field on the source side, you need to know exactly which destination board the row belongs on, which column type each value will store into, and what will serve as the upsert key. The table below summarises the objects you will touch in a monday Work Management migration.

ObjectWhat it storesRequiredTier
WorkspaceTop-level container for a department, product line or clientName; admins or board owners can provisionAll tiers; per-tier workspace count varies
FolderOptional grouping of boards within a workspaceName; nestable one level deepAll tiers
Board (project / process)A single project, process or list — the schema lives hereName; column schema defined per boardAll tiers; per-board item caps scale with plan80
Group (sprint / phase / stage)A section of items inside a boardName; default groups created on import if absentAll tiers
Item (task)A single task, ticket, request or work recordItem name; column values mapped per column typeAll tiers; 10,000 items per board on most plans, 100,000 on Enterprise80
Subitem (subtask)Child rows under a parent itemParent item ID, subitem name; separate column schemaAll tiers; subitem boards inherit their own columns
Updates threadThreaded comments, mentions and rich-text discussion on each itemLogged via UIAll tiers; no native bulk-import path for historical comments137
Files column / Files galleryAttachments associated with an item or an UpdateFiles column on the destination boardAll tiers; 500 MB per item, storage cap scales per plan88
WorkdocStandalone document linked to a board or itemCreated in the workspace; referenced via link columnAll tiers; per-tier Workdoc limits

There is no platform-enforced unique identifier on a monday board — item names are not unique, and the system always assigns an internal numeric Item ID on create. To upsert deterministically you create a Text or Number column on the destination board, fill it from the source export with a stable external ID (UUID or source platform PK), and use that column as your match key in the ingest job15.

Connect Boards columns link items across boards — a Task item links to one or more Project items, and a Mirror column then pulls through specific Project fields onto the Task view without duplicating storage. This is how cross-project dependencies are modelled. Mirror columns are read-only by default and recompute when the source column changes.

Column types are where the schema actually lives. The catalogue below covers the column types that carry the load on a Work Management migration and the limits you need to plan around.

Field typeLimitNotes
Text / Long TextNo documented hard char cap; UI handles up to ~64kLong Text supports line breaks; Text does not46
StatusUp to 40 labels per columnWorkflow stage; each label has an internal index value46
DropdownUp to 1,000 labels per column; 20,000 labels per boardMulti-select; semicolon-delimited on import39
NumbersStandard 64-bit floatStory points, estimates, effort; strip currency symbols
Date / Date & TimeISO-8601 with explicit JSON wrapper for programmatic loadsProgrammatic loads require the documented {"date":...} shape; UI accepts looser formats69
TimelineStart + end date pairDrives the Gantt view; pair with Dependency column
DependencyOne Dependency column per boardPro+ tier only; modes are Flexible, Strict, or No-action34
Time TrackingMultiple sessions per cell, manually editableStores start/stop intervals; bulk-load via JSON history payload138
PeopleOne or more users per cellAssignee column; resolves by monday user ID — pre-provision first52
Connect BoardsUp to ~10,000 linked items per column on a single itemCross-project links; required for Mirror columns
MirrorDepends on source column typeRead-only pull-through; cannot be written via import
FormulaSpreadsheet-style expressionPro+ tier; recomputed on platform — does not import40
Files500 MB per item; no per-cell file count capInline upload or link from Drive/Dropbox/Box/OneDrive88
Required columnsUp to 100 per boardPro+ tier; turn on after the initial import or rows are rejected71

Relationships in monday Work Management are modelled through Connect Boards for cross-board references and through the Dependency column for in-board task dependencies. There is no master-detail or cascade-delete construct — deleting a parent item does not delete its subitems or its connected items, so any cascade behaviour from the source has to be replicated via automation recipes.

Pre-migration prep — the work before you touch monday.com

What must be true on the source, the destination, and across the team before the first row hits the importer.

The single best predictor of a clean monday Work Management migration is how much work you do on the source side before the first import button is pressed. monday does not deduplicate items on import — it will create two separate Task items for the same task name if you let it — so cleansing has to happen in the export file, not in the destination.

monday does not deduplicate items on import. Two rows with the same task name become two separate items — clean the file, not the board.

Treat the source export as raw material that needs to be shaped to monday's expected formats — task names trimmed, dates rewritten to ISO-8601 with the JSON wrapper required for programmatic loads, Status and Dropdown values matched character-for-character to destination labels, assignees resolved to monday user IDs or emails of users that already exist on the account, and time-tracking durations converted from any source unit (hours, minutes, decimal hours) to monday's session-interval shape.

Source-side prep

  • Audit and dedup the source database before export. Excel's Data → Remove Duplicates, Google Sheets' Data → Data cleanup → Remove duplicates, or a third-party dedup tool keyed on task ID and parent-project ID — monday will not catch case-only or whitespace duplicates.
  • Match picklist values exactly to monday Status and Dropdown labels — including casing and punctuation. The importer creates a new Status label on the fly for any unmatched value, which silently bloats the column past its 40-label ceiling on Status46.
  • Decide the project hierarchy before export. Will each source project become one board, one group, or a row on a portfolio board? The cleanest pattern is: portfolio board (one row per project) connecting via Connect Boards to one delivery board per project, with groups representing sprint or phase.
  • Stamp a stable external ID on every record in the source export — a UUID or the source platform's primary key — so re-runs and Connect Boards linking are deterministic15.
  • Decide what is in scope for historical activities. Comments/Updates do not have a documented bulk-import path, so historical discussion is either logged manually, attached as a Long Text Legacy comments column on the parent item, or imported into a parallel comments board you build137.

Destination-side prep

  • Provision users first, ideally via Okta, Microsoft Entra ID or Google Workspace single sign-on, and assign seats and roles before importing — the People column resolves by monday user ID, and rows whose assignee cannot be matched land with no person set52.
  • Build the workspace, folders and boards from the right monday template — Project Management, Single Project, Agile Sprints, or a custom blueprint — so the column schema is sensible before you load. Rebuilding column-by-column later is slow80.
  • Pre-create every custom column on the right board with the right column type. Type-conversion in place is limited; once a Numbers column exists, you cannot retroactively change it to Status without recreating it and losing the data.
  • Add the Dependency column and configure its mode (Flexible, Strict, or No-action) before importing tasks — only one Dependency column is allowed per board, and the mode determines what happens when a parent moves34.
  • Set Required columns (Pro+ tier) only after the initial import — required columns block item creation when the value is missing and fail the import outright71.

People prep

Cutover only works if humans cooperate. Lock down a source-system freeze window — typically 24 to 72 hours — and communicate it to every department. Train delivery leads on the item card, the Updates thread, the Timeline (Gantt) view, the Workload view and the Dependency column before go-live.

A clean Asana-to-monday move of under 5,000 tasks runs one to two business days; a complex Jira-to-monday migration with rebuilt automations, multi-board structure and historical comments runs two to twelve weeks. Build the human runway accordingly.

Import mechanisms: UI wizard, CSV/Excel, and bulk ingest jobs

Three paths in, each with different limits and shapes. Picking the wrong one is how mid-migrations stall at scale.

monday Work Management exposes three load paths and the right one depends on dataset size, board count, and whether the load needs to be repeatable. The UI importer covers most one-shot migrations under 8,000 items per board. The bulk ingest job pattern handles programmatic, repeatable, and very large loads. Third-party staging tools sit on top of both and add transformation and dedup layers.

UI importer (CSV / Excel)

The native importer lives on every board under Add → Import items → From Excel or From CSV13. It accepts CSV, XLS and XLSX. The wizard auto-detects columns, lets you map each source column to an existing board column or create a new one of an inferred type, and runs the load synchronously for files under a few thousand rows. Items land in the group you select.

Three limits matter. Files can carry up to 8,000 rows and 100 columns per import (only the first 50 columns are mapped on a new-board import)10. Status column labels are capped at 40 unique values46; if the source has more, collapse them in the file before import.

The importer also does not deduplicate — rows with the same item name create new items every time. The UI importer is the right call for one-shot loads under 5,000 items per board, or any time you want a visual column-mapping review before commit.

Bulk ingest jobs

For larger loads, monday exposes two bulk-load job patterns. The ingest_items job accepts up to 10,000 rows per job and is available to any caller; the backfill_items job is admin-only and raises the cap to 20,000 rows for the one-time seed before users go live15. Both jobs accept a CSV uploaded to a pre-signed URL and return a job_id polled with fetch_job_status.

Use ingest_items for ongoing sync work and backfill_items exactly once — at the start, before users touch the board. Both jobs accept the same column-mapping payload as the UI importer. Choose the bulk-job path when the load is over 5,000 items per board, when you need to populate Connect Boards and Dependency relationships at scale, or when the migration needs to be repeatable and audit-logged from your side.

Third-party staging tools

Tools like Fivetran, Airbyte, Stitch, Workato, Make and n8n sit between the source and monday. They are used in two ways: (a) reverse-ETL, where the source loads into a warehouse, gets transformed in SQL, then syncs into monday; and (b) staging-and-validate, where the tool handles file generation, type coercion and dedup before feeding the bulk-ingest job. Getint and Unito add a packaged Jira/Asana/Trello-to-monday flow that preserves comments and attachments as a paid add-on.

For one-time migrations, the value of an iPaaS layer is repeatability under failure; for ongoing syncs (the post-migration phase), they become the system of integration.

Mapping your data into monday.com

The longest section — because column mapping, dependencies, time tracking and Updates threading are where almost every monday migration that fails actually breaks.

Mapping is where every migration earns its scars. The decisions you make in your mapping spreadsheet — which board, which column type, which Dependency mode, which Connect Boards link — determine whether the Gantt view works on day two, whether automations fire correctly on day five, and whether your delivery leads trust the data on day thirty.

Work board by board, top to bottom of the import order: a Portfolio board first (so each project board can link back to a portfolio row), then per-project Task boards, then subitems for subtasks, then Connect Boards links, then dependencies, then time-tracking history, then Updates and attachments where in scope.

Project hierarchy and task structure

Most source PM tools nest a hierarchy — Asana has Workspace → Project → Section → Task → Subtask; Jira has Project → Epic → Story → Subtask; Trello has Board → List → Card → Checklist. monday's native hierarchy is Workspace → Folder → Board → Group → Item → Subitem80.

The clean mapping is: source-project → monday board (one board per project), source-section/sprint → monday group, source-task → monday item, source-subtask → monday subitem. Epics, themes and other higher-level constructs map best to a separate Portfolio board, with each Epic linked to the per-project board via Connect Boards.

Excel imports treat subitems as flat items by default — the importer brings them in as top-level items, and you then convert them to subitems either manually one at a time or by running a second-pass load that creates subitems against the parent's Item ID37. Plan for the second pass; do not assume a single CSV will produce the hierarchy.

Common source → monday Item mapping
SourceDestinationNote
task_name / summaryItem nameRequired; trim and de-quote on export
assignee / ownerPeople column (Assignee)Map by monday user ID or email; pre-provision users first52
status / workflow_stateStatus columnMatch labels exactly; up to 40 labels per column46
priority / severityStatus or Dropdown columnStatus if 4–5 fixed values; Dropdown if more or multi-select
due_dateDate column or Timeline columnISO-8601 with {"date":...} JSON for programmatic loads; UI accepts looser formats69
start_date / planned_startTimeline column (start)Pair with end_date to drive the Gantt view
estimate / story_pointsNumbers columnStrip units; store points or hours per a column-level convention
parent_task_idSubitem-of via second-pass conversionFlat CSV import does not nest; convert in a follow-up pass37
epic_id / project_idConnect Boards → Portfolio boardSet in a second pass once the Portfolio board exists

Task dependencies

monday models task dependencies through a single Dependency column per board, configured at column-creation time with one of three modes: Flexible (date shifts are suggested), Strict (date shifts are enforced), or No-action (the link is informational only)34. The Dependency column is gated to the Pro and Enterprise plans.

Only one Dependency column is allowed per board — if your source models multiple dependency types (finish-to-start, start-to-start, finish-to-finish), monday will collapse them into a single "depends on" link unless you replicate the type as a separate Text or Dropdown column.

Dependencies are loaded in a second pass after items exist, because the Dependency column references Item IDs and those IDs are assigned by monday on create. The pattern is: (1) export source dependencies as a (predecessor, successor) edge list; (2) import items and capture each row's monday Item ID in a lookup keyed on your external-ID column; (3) iterate edges and write the Dependency column value.

Time tracking history

The Time Tracking column logs work intervals on each item as a sequence of start/stop sessions, and clicking into a cell opens the history and log where each session can be manually edited138. The column carries the total automatically.

To preserve historical session data from a source like Toggl, Harvest or Jira Tempo, export each row as (item-id, start-timestamp, end-timestamp, user-email) tuples and load them into the Time Tracking column as a JSON history payload — the column accepts a session list, with the running total derived from the sessions.

If the source only stores aggregate durations per task rather than individual sessions, the simplest preserving pattern is to load a single backdated session per task covering the aggregate duration, with the source assignee as the session owner. A parallel Legacy Hours Numbers column on the same item gives reporting an unambiguous total that does not depend on session resolution.

Comments and Updates threading

monday's per-item Updates thread carries threaded comments, mentions, rich-text formatting, file attachments and replies. The catch: there is no documented native path for bulk-importing historical Updates with original authors and timestamps preserved as the original posting metadata — community threads from monday users trying to backfill years of comment history are unresolved137. Updates can be created programmatically, but each call posts as the loader at the current timestamp, not as the original author at the original time.

The patterns most teams adopt: (a) post each historical comment as a new Update with the original author and timestamp prepended in the body text as [2024-03-12, Jane Smith]: …, accepting that the metadata is in the body rather than the structured field; (b) attach a Long Text Legacy comments column on the parent item with the most recent N comments inline, formatted for readability; or (c) keep the source platform in read-only archive for 12 to 24 months and link out via URL.

Custom workflow status and recurring tasks

Custom workflow statuses live in the Status column, color-coded with up to 40 labels per column46. For each board with a non-default workflow, configure the Status column labels before importing — order them left-to-right to match the workflow progression so the Kanban view groups make sense.

If the source has more than 40 statuses, either collapse adjacent values during transform or split the status into a Status column (a coarse 4–6 label workflow stage) and a Sub-status Dropdown column (the fine-grained value).

Recurring tasks are not a column — they are built as an automation recipe. The pattern is Every time period, create item in group, configured under the Automate button on the board; periods can be daily, weekly, monthly or a custom interval139.

Migration implication: a recurring task in the source platform should be migrated as a single template item plus an automation that recreates it on schedule, not as 52 backdated weekly rows. Build the recipe inventory from the source first, prioritise the top recurring patterns, and rebuild those before go-live.

Custom-column mapping strategy

Resist the urge to map every source custom field one-to-one. Migrate only the columns used by an active process, report or dashboard in the last 12 months. Excess columns weaken governance, slow board loads, and make Connect Boards and Mirror columns harder to audit. monday boards have no documented hard cap on columns per board, but past ~50 columns the item card becomes unwieldy and delivery leads stop trusting the view.

For picklist fields whose source values do not match the destination, either: (1) extend the destination Status/Dropdown column with the missing labels, (2) collapse adjacent values during transform, or (3) introduce a parallel Text column that holds the legacy value verbatim. Formula columns (Pro+ tier) do not import — monday recomputes them on-platform — so any source formula must be rebuilt as a monday Formula column expression40.

Files and attachments

Files attach to items via the Files column or inline in Updates. The cap is 500 MB per item88; if files exceed that, the supported path is to zip them or upload from Google Drive, Dropbox, Box or OneDrive via the cloud-storage integration. Large attachment estates (hundreds of GB) typically use the cloud-storage link pattern, with a deep link stored in a URL column on the item.

Storage allowance is tier-dependent — Free gets 500 MB, Basic gets 5 GB, Standard gets 20 GB, Pro gets 100 GB, and Enterprise is effectively unlimited. Plan for storage tier consumption before you bulk-upload — the account-wide cap aggregates across every board, not just the project boards in scope.

Audit trail, ownership and original timestamps

monday's per-item Activity Log captures column-value changes for a retention period that scales per plan — 1 week on Basic, 6 months on Standard, 1 year on Pro and 5 years on Enterprise. The system-managed Created timestamp is stamped to import day and cannot be overwritten through the standard create or ingest paths. To preserve the original audit trail, create Legacy Created Date and Legacy Created By columns on every board and populate them from the source export.

Ownership via the People column works only if the monday user ID or email exists at the moment of import; rows whose assignee cannot be resolved land with no person set, which silently breaks downstream owner-based automations. Account-level activity audit logging is Enterprise-only; lower tiers see per-item history in the Activity Log panel but not account-wide events.

The pitfalls that derail monday.com migrations

Nine specific failure modes — ranked by impact, each tied to the exact monday mechanism that breaks.

Validation and cutover

What to verify after the import job, in what order — and how to fail safely when something is wrong.

Validation is the bridge between the import finishing and users being allowed in. Field-engineering practice on monday Work Management migrations follows a three-stage validation: a test load of 10 percent of items with stakeholder spot-checks, the full load with real-time monitoring of item counts and Dependency-column integrity, and a 30-day post-migration data-quality audit. The most reliable signal is having delivery leads verify their own boards — they know what right looks like better than any reconciliation script.

Build a reconciliation queries spreadsheet that compares source and destination on each of these counts. Anything outside a 0.5 percent variance gets investigated before users get login access.

  • Total items per board vs source — minus deliberately excluded rows (archived projects, closed-won deals, completed-and-purged tasks).
  • Total subitems per parent item vs source — confirming the second-pass subitem conversion did not orphan rows or duplicate the parent.
  • Total dependencies per board — count edges in the source dependency graph and confirm the Dependency column in monday carries the same edge count, with edge direction (predecessor → successor) intact.
  • Sum of time-tracked hours per board per assignee vs source — a non-trivial variance usually signals a session-history payload error or a unit mismatch (decimal hours vs HH:MM).
  • Status label distribution per board — group items by Status label and confirm no rogue labels were created on the fly by mismatched source values46.
  • Connect Boards link counts — for cross-project links, count Task→Portfolio links and compare against source-derived expected counts; missing links cause silent Mirror column blanks.
  • People column distribution — group items by assignee and confirm no item landed unowned that should not have, and no row landed on a Legacy Owner placeholder when an active assignee existed.
  • Unique-identifier integrity — count distinct external-ID values across all imported boards; any duplicates indicate the dedup transform missed cases (monday will not catch them).

On top of reconciliation, run a manual spot-check protocol: pick 30 random items across boards and verify each column value, dependency link and time-tracking total against the source UI. Pick five high-complexity projects and trace the full Connect Boards graph — Portfolio link, dependency chain, subitems and Mirror columns. If a non-trivial discrepancy shows up in three or more of the 30, halt the load, fix the root cause, and re-import the affected items by external-ID column.

Rollback on monday is per-item, not per-import. The Activity Log on each item supports undo of recent column-value changes, but there is no native bulk-undo for an entire import batch. The community-built LogBack app provides per-board undo for bulk-edit accidents, and the Rewind backup product offers granular per-board restore for items and columns. Neither is a one-click rollback of a 50,000-row ingest job.

The real rollback strategy remains: export everything before the import starts, stamp every imported item with an Import Batch ID Text column, and if catastrophe strikes, bulk-delete by that batch ID, then re-import from the cleaned source.

Cutover sequencing: (1) source goes read-only and the team is notified; (2) final delta export captures everything that changed during the test-import window; (3) delta is imported via ingest_items; (4) reconciliation runs; (5) Connect Boards links and Dependency-column edges are populated in a second pass.

Then (6) automation recipes for recurring tasks and notifications are turned on; (7) users get login access and a 48-hour hyper-care window with the migration lead on call; (8) source decommission is scheduled for 30 to 90 days out, never the same day.

Migration partners and tools

Certified monday Partners, iPaaS vendors, specialist migration shops — what each is good for and how to choose.

The monday.com Partner Program tiers Diamond, Platinum, Gold, Silver and Bronze partners by certifications, customer count and revenue. For Work Management migrations specifically, partners with explicit Jira-to-monday, Asana-to-monday or Smartsheet-to-monday practices tend to ship cleaner than generalist implementation shops because they understand the dependency-graph, subitem-conversion and time-tracking-history mechanics that derail naive imports.

Partners commonly named in the Work Management corner of the market run fixed-scope migration packages alongside ongoing managed services. Pricing tiers tend to follow board count, item count and historical-data depth: a single-board, under-5,000-item move with no comments runs at the low end; a multi-workspace migration with dependencies, time-tracking history and Updates preservation runs at the high end.

Getint and Unito add a packaged Jira/Asana/Trello-to-monday flow with comment and attachment preservation as a paid integration — Getint is licensed per migration run rather than per seat, which makes it economical for a one-time backfill.

On the ETL and iPaaS side, Fivetran, Airbyte, Stitch, Workato, Make, n8n and Zapier all have monday connectors. Their role in a migration is rarely the migration itself — it is the staging layer that lands source data into a warehouse, the transformation layer that converts picklist values and resolves owner IDs to monday user IDs, and the ongoing-sync layer that takes over once the one-time migration is complete.

Airbyte and Fivetran are common picks for warehouse-first teams; Workato and Make are common where the migration is bundled with workflow automation rebuilds; n8n is used heavily for monday-side automation recipes post-migration where the team wants more control than the native automation builder offers.

Managed-migration cost ranges vary widely. An Asana-to-monday or Trello-to-monday move under 5,000 tasks with no historical comments and a single workspace often lands in the $2,500–$8,000 range. A Jira-to-monday project with dependencies, time-tracking history, subitem conversion and Updates preservation typically runs $15,000–$80,000, with the upper end driven by item count, dependency-graph density, historical-comment depth and the number of integrations that need rebuilding rather than re-pointed.

For teams that want to outsource the migration end-to-end, FlitStack specialises in monday.com Work Management migrations and handles the column-type design, project-hierarchy mapping, dependency-graph load, subitem conversion, time-tracking history preservation and validation work described in Sections 5 and 7 of this guide. Pricing is fixed-fee, based on item count and source platform, with separate line items for Updates-thread depth and Dependency-graph complexity so the scope is transparent before signature. [Explore FlitStack →](/contact)

This is one of several legitimate paths — the right choice for any given team depends on whether they want a Diamond/Platinum monday Partner, a packaged migration product like Getint or Unito, an iPaaS-first approach, or a specialist migration vendor.

monday Work Management migration checklist

An exhaustive, phased punch list for moving an existing project workspace onto monday.com Work Management — from scoping through cutover to source decommission. Typical timeline: 6–16 weeks.

0. Decide & Plan10 tasks
  • Document the migration objective and the trigger event in one paragraph. Capture why the move is happening now (tool consolidation, plan change, residency, M&A, sunset of source system) so later scope debates can be settled against the original intent.
  • Define the in-scope object set: Workspaces, Folders, Boards, Groups, Items, Subitems, Updates, Files, Users, Teams. List each object explicitly with an in-scope or out-of-scope flag. Treat Updates threads, Docs and dashboards as separate decisions from Items.If skipped: Implicit scope expands mid-project as stakeholders discover missing data, blowing the timeline.
  • Decide the historical-data window: how many years of source items, comments and attachments come across. Pair each in-scope object with a date cut-off. Older items can be archived to read-only storage instead of imported.If skipped: Importing unbounded history inflates board item counts, breaches per-board ceilings and slows every view.
  • Choose the monday.com plan tier before any build work. Map required features to plan: Dependency column, Time Tracking, formula columns and private boards require Pro; advanced provisioning, audit log, HIPAA and IP restrictions require Enterprise.If skipped: Building on Standard then discovering a Pro-only column type forces a re-architecture mid-migration.
  • Select the hosting region: US, EU (Frankfurt) or APAC. Region is set at account creation and cannot be changed after the fact by self-service. EU residents subject to GDPR data-residency commitments must request EU before the account is provisioned.If skipped: An account created in the wrong region requires a full account-to-account move to relocate data later.
  • Identify legal and compliance constraints that gate the cutover. Capture GDPR data-processing addenda, HIPAA BAA requirement, SOC 2 evidence needs, customer contracts that name the source platform, and any retention policies that change on cutover.If skipped: A missing signed BAA on an Enterprise HIPAA tier means uploaded PHI is non-compliant from day one.
  • Assign a single accountable migration owner (DRI) and a named delegate. One person signs off each phase. Cross-functional input is welcome; ownership is not shared.
  • Document explicit success criteria for cutover. Examples: every active item has the same status, owner and due date in destination as source; every attachment opens; every dashboard has a matching destination view.If skipped: Without written criteria, sign-off becomes a negotiation instead of a verification step.
  • Set the target cutover window, the source-system freeze date, and a no-go fallback date. Pick a window that avoids fiscal close, sprint boundaries and known release freezes for downstream teams.
  • List explicit out-of-scope items in writing. Common exclusions: source-system automations, dashboards, archived items beyond cut-off, source-system custom apps. Saying "no" up front is cheaper than saying it later.
1. Pre-Migration Prep29 tasks
  • Export source record counts per object as a numeric baseline. Capture counts per project, per status, per owner. Save the export as the reconciliation reference for Phase 6.If skipped: Without a baseline, post-cutover deltas can be explained away as "normal" instead of investigated.
  • Run dedup analysis on source items using a stable match key. Match on source ID where present, otherwise on (project, title, owner, due-date). Resolve duplicates in the source while you still have its dedup tooling.If skipped: Duplicates merged after import require manual cleanup against destination IDs that did not exist at source time.
  • Normalize email casing and verify each user email resolves to a real mailbox. Lowercase all email addresses before export. Items assigned to bounced mailboxes need owner reassignment before cutover.
  • Standardize date and datetime values to ISO-8601 with explicit timezone. monday.com stores date columns in UTC and renders per-user timezone; mixed-format source dates surface as off-by-one-day errors in calendar and timeline views.If skipped: Date column imports silently shift days at the date-line, producing wrong deadlines on hundreds of items.
  • Identify and resolve items missing required fields in the destination schema. Required columns in monday.com block item creation if empty. Pre-fill or strip the requirement before load.If skipped: Import jobs abort partway when a required column is unset, leaving the board in a half-loaded state.
  • Audit source picklist / status values and rationalize them. Status columns on monday.com cap at 40 labels per column. Collapse near-duplicate statuses ("Done", "Done!", "Completed") in source before mapping.If skipped: Hitting the 40-label cap mid-import forces emergency label consolidation under cutover pressure.
  • Audit source dropdown / multi-select fields against the per-board 20,000-label ceiling. monday.com supports 1,000 labels per Dropdown column and 20,000 labels per board across all dropdowns. Aggressive tagging in source can exceed this.
  • Document and resolve any field-level encoding issues (non-UTF-8 text, smart-quote artefacts). Re-encode to UTF-8 at export. The CSV importer rejects mixed encodings silently in some cells.
  • Provision the production monday.com account in the chosen region. If EU residency is required, request the EU region during provisioning. Self-service account creation defaults to US.If skipped: An EU-resident customer left on the US tenant must be moved account-to-account later, costing a second migration.
  • Provision a separate sandbox account or sandbox workspace for the dry run. monday.com does not offer a built-in sandbox; create a separate paid account on the same tier or use an isolated workspace with no production users.If skipped: Testing in the production workspace exposes incomplete data to end users before sign-off.
  • Configure account-level settings: default timezone, workweek, language, default item-name column. These cascade into board defaults and affect how imported dates render.
  • Design and create the Workspace → Folder → Board → Group hierarchy in production. Decide whether each source project becomes a Board (one project per board) or a Group inside a portfolio Board. Document the rule and stick to it.If skipped: Mixing the two models on the same migration breaks rollups, Mirror columns and cross-board reporting.
  • Create every column on every destination board before any import. Decide column types up front: Status (40-label cap), Dropdown (1,000-label cap), Date, Timeline, People, Numbers, Text, Long Text, Dependency, Time Tracking, Mirror, Connect Boards.If skipped: Importing into a missing column silently drops the column's data on the existing-board flow.
  • Stay under the 100-column file limit and the existing-board 50-imported-column cap when designing board width. Native CSV/Excel import accepts up to 100 columns in the file with the first 50 imported on a new board, 100 on existing. Split very wide source schemas into separate boards or mirror groups.If skipped: A 70-column board imported into a fresh board loses everything beyond column 50 with no per-cell warning.
  • Stay under the 10,000-item-per-board ceiling (100,000 on Enterprise) when sizing the board layout. If a source project exceeds the ceiling, split by year, region or sub-project across multiple boards joined by Connect Boards.If skipped: Loads above the ceiling fail mid-import and partial data is non-trivial to roll back.
  • Configure the Dependency column mode (Flexible, Strict or Blocking) on every board that needs dependencies. Mode is per-column and applies to all dependency relationships on that board. Pick the mode before loading any dependency data.If skipped: Switching dependency mode after load can re-shift hundreds of dependent dates.
  • Add the Time Tracking column to boards that need session history. Time Tracking is a Pro+ column and stores sessions with start, stop, user and duration. Add it before importing any historical time entries.
  • Build Connect Boards and Mirror column relationships up front to match source cross-project links. Connect Boards links one item to items on another board; Mirror reflects a column from the linked item. Both must be configured before the upsert that creates the relationship.If skipped: Items load without their cross-board links and have to be re-stitched item-by-item after cutover.
  • Set column-level permissions for any sensitive fields (budget, salary, client revenue). Column permissions are configured per board; without them, every board member can read every column.
  • Create Teams and assign users to Teams matching the source-system access groups. Teams are the unit monday.com uses for board sharing on private and shareable boards.
  • Provision all destination users with the correct role: Admin, Member, Viewer or Guest. Guest seats are billed differently from Member seats. Pick the role intentionally; do not default everyone to Member.If skipped: Over-provisioning Member seats inflates the seat count and the annual invoice.
  • Configure SSO and (Enterprise) automated provisioning before user load. Automated user provisioning is Enterprise-only. JIT-via-SSO works on lower tiers but does not deprovision.
  • Disable, pause or scope every Automation recipe on destination boards until cutover. Recipes firing on imported items will notify, reassign or move thousands of items before validation.If skipped: Status-change recipes fire on every imported row, generating a flood of emails and Slack pings to end users.
  • Disable destination email notifications for users involved in the import. Bulk item creation generates a notification per item per subscriber by default.
  • Provision a dedicated import service account separate from any personal admin. Use a dedicated account, not a personal admin, so post-cutover audit logs show migration writes separately from human edits.If skipped: Mixing migration writes with admin writes makes audit-log triage impossible after cutover.
  • Announce the source-system freeze window to every affected user. Include the exact start time, the read-only date and the destination-go-live time. Repeat 72h, 24h and 1h before freeze.
  • Schedule destination training for end users, segmented by role. Item owners, board owners and workspace admins need different sessions. Run them in the week before cutover so the muscle memory is fresh.
  • Designate first-responders for the 48 hours after cutover. Name two on-call admins per timezone. Publish a single intake channel for issues so triage is centralized.
  • Pre-write the cutover go/no-go checklist and circulate it to every stakeholder. Items: source frozen, exports complete, sandbox sign-off in hand, destination automations paused, rollback plan ready.
2. Source Export13 tasks
  • Export every in-scope project / board as CSV or XLSX with all standard and custom columns included. Use the source system's bulk export. Save the file timestamp with the file.If skipped: Per-record extraction loops on large projects rarely finish without interruption and produce inconsistent snapshots.
  • Export tasks / items separately from projects / boards so the parent-child relationship is preserved. Keep a join key (project_id or board_id) in the item export.
  • Export subtasks / subitems with an explicit parent_item_id column. monday.com subitems require a parent item. The link must be present in the import file.If skipped: Subitems without a parent link land at the top level and have to be reparented one by one.
  • Export task dependencies (predecessor / successor pairs) as a separate relationship file. Capture (from_item_id, to_item_id, dependency_type). monday.com's Dependency column accepts pairs but the import file must enumerate them.
  • Export time-entry / time-tracking history as a separate file with item_id, user_email, start_ts, end_ts and duration. Time Tracking sessions on monday.com are stored per item with full session-level history; map source time entries to sessions.If skipped: Aggregated time totals without session detail lose the ability to attribute hours to the right user post-migration.
  • Export comments / updates / notes as a separate file with item_id, author_email, created_at and body. Comments do not import into the native Updates thread via CSV; capture them anyway for the chosen preservation strategy in Phase 3.If skipped: Discarding source comments because they "do not import natively" loses years of decision context.
  • Export the user list with email, full name, role and team membership. Map source roles to monday.com Admin / Member / Viewer / Guest before user load.
  • Export the full source attachment set with filename, size, owner, content-type and parent item_id. Pull binaries to a staging bucket. Capture an MD5/SHA-256 per file so post-import integrity can be verified.If skipped: Re-fetching missing attachments after the source goes read-only is harder than re-uploading from a fresh pull.
  • Export workflow / status definitions and their order per source object. These become the Status column label list and order on destination boards. Capture color codes too where reusing palette matters.
  • Export the source automation / rule definitions as documentation, not data. Recipes do not transfer; screenshots and a JSON dump of each rule become the rebuild spec on monday.com.
  • Export reports, dashboards and saved views as definition + screenshot pairs. Dashboards rebuild manually on monday.com using widgets. Captured definitions make the rebuild a documentation task, not a discovery task.
  • Export permissions / sharing per project so destination board permissions can be reconstructed. Capture both the share scope (public, team, named users) and any field-level restrictions.
  • Capture the exact timestamp of every export. This timestamp defines the delta the cutover-day export must catch up. Write it into the file metadata, not just the filename.If skipped: Without a known export timestamp, the delta export at cutover misses any record edited inside an ambiguous window.
3. Transform & Map28 tasks
  • Build a master mapping spreadsheet: one row per source field with destination column, type, transform and required-on-import flag. Include nullability, default value and whether the column is part of any Connect Boards or Mirror relationship.If skipped: Without a single mapping artefact, transformation rules drift between engineers and the same source field maps two different ways.
  • Resolve every source field with no destination equivalent: drop, concatenate into Long Text, or create a new column. Document the decision in the mapping spreadsheet. Concatenated fields keep history without bloating column count.
  • Decide the upsert key per object and document it. Typical: source system ID stored in a Text column on monday.com. ingest_items can update items that match this key on re-runs.If skipped: Without a stable upsert key, partial re-imports duplicate every previously loaded row.
  • Resolve Status column label mismatches against the 40-label cap per column. Map ("In Review", "Under Review", "Reviewing") to one label; document the consolidation.
  • Resolve Dropdown column label mismatches against the 1,000-per-column and 20,000-per-board caps. Multi-select source fields with high cardinality (e.g. tags) often need to be collapsed or split across multiple Dropdown columns.
  • Decide the ownership strategy: best-match by email or assign to a single "migration" service user. monday.com's People column needs a valid user reference. Items assigned to deactivated emails fail.If skipped: Items whose owner emails do not resolve to any provisioned user fail to load on the People column.
  • Decide the historical-timestamp strategy. monday.com does not let import overwrite system created_at. Either accept import-time created_at and store the original in a custom Date column, or use ingest_items to preserve where supported.If skipped: If "original created date" reports drive SLA calculations, losing source timestamps misrepresents historical SLA performance.
  • Convert date and datetime fields to ISO-8601 with explicit timezone. monday.com Date columns store date-only; Timeline and Date with time store full timestamps. Confirm the column type per field and write the correct shape.If skipped: Datetime values without timezone shift up to 24 hours depending on the importer's interpretation.
  • Normalize phone numbers to E.164 (+countrycode...). Use a phone-number normalization library in the transform step.
  • Convert currency values to the destination's stored decimal precision and separator. Numbers column on monday.com accepts plain numerics; strip currency symbols and thousands separators before write.
  • Truncate or split text fields that exceed destination column length. Item names truncate at the platform's name length; Long Text columns accept longer content. Re-route any over-length text to Long Text.If skipped: Truncation without warning silently loses the back half of long titles.
  • Re-encode any non-UTF-8 text content as UTF-8. Mixed-encoding CSV files surface as garbled cells with no row-level error.
  • Escape commas, newlines and quote characters in CSV cells per RFC 4180. Newlines inside item names or text columns split rows in some importers; quote-wrap and double-escape internal quotes.If skipped: An unescaped newline in a single cell can break every subsequent row's column alignment.
  • Normalize boolean fields to monday.com Status or Checkbox column values. Source booleans (Y/N, 1/0, true/false) all need to map to a single representation on destination.
  • Implement the chosen ownership strategy across the transformed files. Either resolve every source owner email to a monday.com user_id, or hard-write the migration service user_id everywhere.
  • Stamp original source IDs into a dedicated Text column on every item. Names like source_system_id make later cross-system reporting and audit-log tracing possible.If skipped: Without a back-reference, debugging "why did this item end up here" requires a manual hunt through the source export.
  • Stamp original created_at / modified_at into dedicated Date columns alongside the new system timestamps. These power the audit-trail validation in Phase 6.
  • Decide the attachment strategy: re-upload binaries to monday.com vs. link out to external storage (Google Drive, OneDrive, Dropbox, Box). Per-file upload limit on the Files column is 500 MB; account storage is plan-capped. Large or numerous binaries are better preserved as cloud links.If skipped: Re-uploading every binary can exhaust the account storage cap and silently fail later uploads.
  • Map source project hierarchy onto the Workspace → Folder → Board → Group → Item → Subitem structure. Decide where each level of the source nesting lands. A common pattern: source portfolio → Workspace; source program → Folder; source project → Board; source phase → Group; source task → Item; source subtask → Subitem.If skipped: Flattening five source levels onto monday.com's six without an explicit mapping produces unpredictable parent-child links.
  • Translate source task dependencies into Dependency column pairs and align them with the chosen Dependency mode. Flexible mode allows manual override; Strict and Blocking modes enforce the timeline. The mode must already exist on the destination board (per Phase 1) before pairs are written.If skipped: Importing dependency pairs into a Strict-mode column shifts hundreds of due dates the moment the first pair is created.
  • Translate source time entries into Time Tracking column sessions on a per-item basis. Each session needs start, stop, user and duration. The Time Tracking column stores session-level history that is editable post-load.
  • Build Connect Boards link payloads and Mirror column dependencies for cross-board relationships. Connect Boards holds the link itself; Mirror columns reflect a column from the linked item. Decide which columns Mirror reflects before load so the linked column exists.If skipped: Mirror columns referencing a not-yet-created source column show as empty cells across the destination board.
  • Re-create source recurring-task rules as monday.com Automation recipes scheduled on the destination. Recurring items are a recipe-driven feature on monday.com ("Every time period, create a new group / item"). Document each source recurrence and queue the recipe for activation post-cutover.
  • Plan how source Updates / comments will be preserved on destination. The Updates thread cannot be backfilled by CSV. Options: re-post each comment as a new Update after item creation, or concatenate into a Long Text "history" column on the item.If skipped: Re-posting every historical update at high rate against the destination platform's per-tenant throughput caps will stall partway through.
  • Decide whether attachments land on the Files column or remain as cloud-storage links on a Link column. File column uploads count against account storage and re-host the binary; Link columns to Google Drive / OneDrive / Dropbox / Box preserve the source-of-truth elsewhere.
  • Choose the import mechanism per object type: native CSV/Excel UI, ingest_items, or backfill_items. Native UI suits one-off boards under 8,000 rows. ingest_items handles recurring programmatic loads at 10,000 rows per job. backfill_items handles 20,000 rows per job and is account-admin-only for an initial seed.
  • Size jobs to respect the platform's complexity budget. Per-tenant reads and writes are capped on a per-minute complexity budget. Cost out each batch before scheduling.If skipped: Unsized batches trigger complexity-limit errors mid-job, leaving partial loads that have to be reconciled by hand.
  • Stage import files in the order: Users → Teams → Workspaces → Folders → Boards → Groups → Items → Subitems → Dependencies → Time entries → Updates → Files. Each later step depends on IDs produced by earlier steps; the order is fixed.If skipped: Loading subitems before items leaves orphans; loading dependencies before items errors at every pair.
4. Sandbox Test Migration15 tasks
  • Load a representative 1–5% sample of each object into the sandbox. Sample across status values, owners, dates and custom fields. Random sampling is fine; cherry-picked easy rows are not.If skipped: Sampling only the easy rows hides the field-type gotchas until production load.
  • Validate field-by-field on 10–20 random sandbox items that values landed in the right column with the right type. Open each item and compare every column to the source row.
  • Specifically test long strings, special characters, embedded newlines and emoji. These are the cells that surface CSV escaping bugs.
  • Test Status column imports against the 40-label cap and confirm new labels are not auto-created beyond the cap. Verify each label landed in the intended position and color.
  • Test Date and Timeline column imports across timezones to confirm no day-shift. Pick sample rows from at least three timezones, including one east of UTC and one west, and verify the rendered date matches the source.If skipped: Day-shift bugs found in production force a per-row recompute against the source export.
  • Test Dependency column loads in the chosen mode. Confirm dependency pairs link the right predecessor and successor, and that no due date shifted unexpectedly under Strict or Blocking mode.
  • Test Time Tracking column loads with session-level history. Open a sample item's Time Tracking history and confirm session start, stop and user are correct.
  • Test Subitem imports and confirm parent linkage is preserved. Native Excel import flow imports subitems as items by default; verify the chosen import path actually preserves the subitem relationship.If skipped: Subitems landing as top-level items requires per-item conversion after the fact.
  • Test Connect Boards and Mirror column linkage. Open a destination item and confirm the linked item resolves and Mirror cells render the expected source column.
  • Run a full-volume timing test of the heaviest board. Time the load of the largest single board to confirm the cutover window has headroom.If skipped: A production board that loads slower than the cutover window leaves the team in a half-migrated state at go-live.
  • Track cumulative complexity-point consumption across the test runs. Sandbox runs draw against the same per-minute quota. Capture the burn rate per job size so production sizing is empirical.
  • Have a domain expert from the team that uses the data spot-check 25–50 sandbox items end to end. Engineers catch type bugs. The team that lives in the data catches semantic bugs.
  • Document every defect, its root cause, and the transform fix. A defect log feeds Phase 6 validation and the post-mortem.
  • Re-run the sandbox load after every transform fix until a full clean run completes. Do not advance to production with known open defects.If skipped: Carrying defects forward to production turns the cutover into the discovery phase.
  • Get written sandbox sign-off from the migration sponsor before scheduling cutover. Sign-off names the sponsor, the date and the explicit success criteria met.
5. Production Cutover11 tasks
  • Confirm the source freeze is in effect and that no new writes have occurred in the last hour. Have an admin lock the source to read-only at the documented freeze time.If skipped: A late source write after the delta export creates an item that never lands on monday.com and is invisible to validation.
  • Take the cutover-day delta export across every object type. Capture every record changed since the Phase 2 baseline timestamp. Merge into the staged import files.
  • Re-run the transform pipeline against the merged datasets and produce final destination-shaped import files. Sanity-check the row counts match the merged input.
  • Confirm destination Automation recipes are paused and notifications are suppressed. Re-verify the Phase 1 pauses are still in effect; recipe state can drift between Phase 1 and cutover.If skipped: A re-enabled recipe firing on import generates thousands of notifications mid-cutover and floods user inboxes.
  • Execute loads in dependency order: Users → Teams → Workspaces → Folders → Boards → Groups → Items → Subitems → Dependencies → Time entries → Updates → Files. Use ingest_items for recurring volumes and backfill_items only for the largest seed loads, per the Phase 3 plan.If skipped: Out-of-order loads error on missing parent IDs and force a partial rollback.
  • Use idempotent upserts keyed on the source-system-ID column for every item load. ingest_items supports update-on-match; configure the match key to the dedicated source-ID Text column.If skipped: Non-idempotent inserts on re-run double every previously loaded row.
  • Capture job_id, row count, success count, error count and error log for every ingest_items / backfill_items job. Poll fetch_job_status until the job completes and persist the result to the migration log.
  • Cross-check destination item counts against source row counts at the end of every load step. If counts diverge, stop, diagnose and re-run the step before advancing.If skipped: Continuing past a count mismatch propagates the deficit through every downstream step.
  • If a load step fails partway, halt the pipeline, diagnose, fix the transform and re-run the failed step idempotently. Do not push through with partial data and plan to clean up later.
  • Re-enable destination Automation recipes once all loads complete and Phase 6 validation has started. Re-enable in waves: first the read-only recipes (notifications), then the side-effect recipes (status changes, item moves), then the integrations.
  • Re-enable destination notifications and email preferences. Reverse the Phase 1 silencing so the platform behaves normally for end users.
6. Validate21 tasks
  • Compare total item count per board: source vs. destination. Investigate any non-zero delta against the migration log; expect the delta to resolve to known excluded rows or known errors.If skipped: An unexplained count delta means rows are missing or duplicated and the team does not know which.
  • Compare open task count per project: source vs. destination. An open-status item that lands closed (or vice versa) skews every dashboard the moment users log in.
  • Compare subitem counts per parent item across the largest 20 parents. Subitem orphan rates surface here.
  • Compare dependency-pair counts per board across the boards that use Dependency columns. Dependency rows often drop quietly during transform.
  • Cross-check 25–50 randomly selected items field-by-field between source and destination. Cover every column type at least once across the sample. Document any divergence and decide whether to fix or accept.If skipped: Skipping random sampling means systematic bugs in rare columns ship to production users.
  • Verify every custom column has at least one populated value where expected. An entirely empty destination column usually means a mapping bug.
  • Verify Subitem-to-Item relationships on a sample of 25 items. Open each item and confirm the subitems list matches source.
  • Verify Connect Boards links resolve and Mirror columns render correctly. Sample one link per relationship type; confirm both directions resolve.If skipped: Broken Mirror columns surface as empty cells in dashboards long after cutover.
  • Verify Time Tracking sessions on a sample of items with the heaviest historical time entries. Open the Time Tracking history and compare per-session entries with the source export.
  • Verify File column attachments open and the file content matches the source binary. Spot-check 20 random attachments; verify checksums match the Phase 2 capture for at least 5.If skipped: Truncated or replaced binaries are only discoverable by opening the file.
  • Verify People column owners resolve to active users on the destination account. Any item still pointing to the migration service user has not had its true owner reassigned.
  • Verify the original created_at / modified_at columns are populated on every item. Confirm the original timestamp survived into the dedicated custom Date columns per Phase 3.If skipped: Items missing the back-reference timestamp lose their audit context permanently.
  • Confirm the destination account is in the contracted hosting region. Account admin → hosting region; for EU customers, verify the region is Frankfurt and that no replica exists outside the EU.If skipped: A US-region account holding EU personal data breaches GDPR Article 44 from cutover onward.
  • Verify the signed BAA is in force if the account holds PHI. HIPAA-Compliant Enterprise Tier must be active and the BAA countersigned before PHI is uploaded.
  • Pull the destination Enterprise Audit Log and confirm the cutover writes are recorded. Filter on the migration service account user_id; cross-check writes against the migration log.
  • Document the data-retention policy on the destination workspace. Capture: who can delete, how long deleted items remain in the recycle bin, and the encryption-at-rest position.
  • Have 3–5 power users from each affected team validate their day-to-day workflows. Scripts: create an item, change its status, set a dependency, log time, mention a teammate, open an attachment, run a view.If skipped: Skipping UAT means real workflow defects ship to every user simultaneously on day 1.
  • Have a board owner re-create one dashboard end-to-end on destination and compare against the source. Dashboards rebuild manually; a clean dry run before opening the platform avoids day-1 reporting gaps.
  • Re-test one full recurring-task recipe end-to-end. Recurring item recipes do not migrate; confirm the rebuilt recipe fires correctly on the documented schedule.
  • Capture and triage every UAT defect; classify each as blocker / non-blocker. Blockers gate the Phase 6 sign-off. Non-blockers carry into Phase 7 cleanup.
  • Capture written sign-off from the migration sponsor against the Phase 0 success criteria. Sign-off references the success criteria document by name and explicitly states each criterion is met.If skipped: Without written sign-off, scope debates re-open weeks later under the heading "the migration was never finished".
7. Post-Migration Cleanup12 tasks
  • Communicate go-live to every end user with login instructions, training links and the support intake channel. Pin the announcement in the company knowledge base; do not rely on email alone.
  • Run live training sessions for end users segmented by role. One session for item owners, one for board owners, one for workspace admins. Record each session.
  • Set the source system to read-only and announce the read-only date. Read-only protects the source as a forensic snapshot during the 30/60/90-day fallback window.If skipped: An editable source post-cutover invites users to update both systems and split the source-of-truth.
  • Rebuild dashboards on the destination using monday.com widgets. Use the Phase 2 dashboard-definition captures as the rebuild spec. Tag every widget with the source name for traceability.
  • Rebuild Automation recipes using the Phase 2 documentation as the spec. Build in waves: notification recipes first, then status-change recipes, then cross-board recipes. Test each recipe in isolation before the next.If skipped: Rebuilding every recipe at once and then enabling them in bulk surfaces interaction bugs as a single tangled outage.
  • Rebuild recurring-task recipes ("Every time period, create...") on the destination. Verify the next-fire date is correct; otherwise the first occurrence post-cutover may not match the source cadence.
  • Re-establish integrations to other systems: calendar, email, BI, identity provider, file storage. Each integration is its own configuration block; do not bundle them into a single "reconnect everything" ticket.
  • Configure ongoing user provisioning via the Enterprise provisioning flow or SSO JIT. Without provisioning, leavers retain access until manually removed.If skipped: Leavers retaining access exposes the platform to insider-risk breaches between offboarding and manual removal.
  • Schedule a 30-day retrospective with the migration team and an executive sponsor. Capture what went well, what did not, and what would change for the next migration.
  • Decide and document the source system's decommission date. Common pattern: 90 days after cutover, after the final retention window passes. Communicate to every user.
  • Archive every source export and the migration log to long-term storage. Encrypted cold storage in S3, Azure Blob or equivalent. Tag with the cutover date and the retention period.If skipped: Discarded source exports remove the only forensic record if a post-cutover dispute arises a year later.
  • Close the migration project formally: final status report, lessons-learned doc, project closure email. A formal close prevents the project re-opening every time someone finds an edge case post-cutover.

Questions, answered

Migrating to monday Work Management: questions

How long does migration to monday.com take?

A small-team migration with under 5,000 tasks and a single workspace runs one to two business days end-to-end. A mid-market project with multi-board structure, task dependencies, time-tracking history and Updates preservation runs two to twelve weeks of elapsed time, including preparation, validation, training and a 48-hour hyper-care window.

Can I migrate from Asana to monday.com?

Yes, and Asana-to-monday is usually the cleanest shape because the object models align well — Projects, Sections, Tasks and Subtasks correspond to Boards, Groups, Items and Subitems. Watch Status label casing against monday's 40-label cap, plan a second pass to convert flat subtask rows into subitems, and rebuild Asana rules as automation recipes.

Can I migrate from Jira to monday.com?

Yes — Jira-to-monday is a common move for non-engineering teams consolidating onto one platform. Epics, Stories and Subtasks map to Portfolio rows, Items and Subitems, but Jira workflows, JQL filters and automation rules do not transfer and need to be rebuilt as monday Status configurations and automation recipes. Comments require a separate preservation strategy.

Does monday.com preserve original timestamps on import?

Partially. The Date column on tasks, the Timeline column, and any custom Date column can be backdated and shows correctly. But system-managed item Created timestamps cannot be overridden — they stamp to import day. Use Legacy Created Date and Legacy Created By Date and Text columns to preserve audit history.

What's the difference between using the UI importer and bulk-ingest jobs for monday.com?

The UI importer accepts CSV and Excel files up to 8,000 rows, runs synchronously, and is best for one-shot loads under 5,000 items per board with a visual column-mapping step. The bulk-ingest jobs use `ingest_items` (10,000 rows per job) or `backfill_items` (20,000 rows, admin-only) for larger volumes, dependencies and subitem conversion.

Can I migrate task dependencies to monday.com?

Yes, but only on Pro and Enterprise plans, and via a second-pass load after items exist. The Dependency column references monday Item IDs, which are assigned on create. Export source dependencies as a predecessor-successor edge list, resolve each side to the monday Item ID, then write the Dependency column value.

What happens to time-tracking history and comments during migration?

Time-tracking sessions can be loaded into the Time Tracking column as a JSON history payload, preserving per-session intervals. Comments and Updates have no documented bulk-import path — the workaround is to post each historical comment as a new Update with the original author and timestamp prefixed in the body text.

Is there an undo or rollback for monday.com imports?

Not for a full import batch. The per-item Activity Log supports undo of recent column changes, and the LogBack app and Rewind backup product add per-board restore. There is no one-click rollback of a 50,000-row ingest job — stamp every imported item with an Import Batch ID column instead.

Get a quote

Moving to monday Work Management?

Tell us where your data lives today and roughly how much there is. We scope the migration and the monday Work Management setup with you, then send a quote.

Get a quote