Migrate from Trello to Nextcloud Deck

How to migrate Trello boards to Nextcloud Deck without losing cards

If you are moving Trello boards to Nextcloud Deck, the migration is an import, either with the occ deck:import command or through the Trello API, followed by a parallel run and a cutover date. Deck is an app inside Nextcloud, so a working Nextcloud server must exist before any board can be imported. In most organizations the internal platform or IT team runs the work, sometimes with an implementation partner who handles the import configuration, testing and hardening. The effort is driven less by the tooling than by how much board history you need to keep and how many people must agree on user mapping before the first import.

The first decision is the import route. Nextcloud Deck documents a configuration file that maps the board owner and each Trello member to a Nextcloud user, so start by listing every Trello member and confirming which Nextcloud account each one should become. Then count the actions on each board. Boards with up to 1,000 actions can use the JSON file route. Busier boards should use the Trello API route, which needs a Trello API key, token and board ID. Run each import against a test instance first, and check card counts, list order, labels, due dates and assignees against the source board. Confirm with your Nextcloud administrator how the import configuration file is stored and who may read it, because it contains credentials for the Trello API route.

Which Trello features map to Nextcloud Deck and which need rework

This table compares the main Trello objects with their Nextcloud Deck equivalents and marks each as clean, needs rework or gap. Read the import column as documented behavior, then confirm the details with a test import of one of your own boards before you commit to a full migration. The main takeaway is that boards, lists and cards carry over directly, while long comments, attachments and Trello administration features need a plan.

Trello feature	Deck behavior on import	Status
Boards and lists	Imported as Deck boards and stacks, with list order kept as the stack order	Clean
Cards	Imported as Deck cards with title and description carried over	Clean
Labels	Mapped to Deck labels; confirm color and name mapping in a test import	Needs rework
Members and owner	Mapped through the configuration file to Nextcloud users; unmatched users need manual assignment	Needs rework
Due dates	Imported as Deck card due dates; confirm time zone handling on your test board	Needs rework
Comments up to 1,000 characters	Imported as card comments	Clean
Comments over 1,000 characters	Placed on the card as attached files, so they are no longer inline text	Needs rework
Attachments and links	Listed in a Markdown table at the end of the card description rather than as native Deck attachments	Needs rework
Checklists	Confirm in a test import how checklist items and completion state appear on the card	Needs rework
Archived cards and boards	Confirm whether archived items are imported; plan to restore or recreate any that you need	Gap
Power-Ups and Atlassian Guard	No direct Deck equivalent; integrations and enterprise administration must be rebuilt or dropped	Gap

Which Trello exports and integrations to plan for

Before importing, decide which source feeds Nextcloud Deck, who maps to which account, and what Trello features will not come across. The four cards below cover the two import routes, the user mapping file and the Power-Ups that need a plan of their own.

Trello JSON file import

The JSON route uses a board export file and brings up to 1,000 actions per board. It is the simpler path for quiet boards, and it is run with the occ deck:import command on the Nextcloud server. Check the action count of each board before you choose it, since a board with heavy history will be truncated without an obvious warning in your own tooling. Confirm with a test board that the cards, labels and checklists you expect appear in Deck.

Trello API import for busy boards

For boards above the 1,000-action limit, Nextcloud recommends importing through the Trello API. The importer needs a Trello API key, a token and the board ID, all issued from the Trello account of a user who can read the board. Treat the token as a credential: store it in the configuration file with restricted file permissions and revoke it after the import. Ask whether the token owner can read every board in scope, because a missing permission will stop the import partway through a batch.

User mapping configuration file

The configuration file maps the board owner and each Trello member to a Nextcloud account. Unmapped members can leave cards assigned to people who no longer exist in Nextcloud, so build the list from the Trello member list before running the import. Match each entry against accounts that already exist, including accounts provisioned through LDAP or single sign-on. Review assignees on a sample of cards after the first run and correct the file before importing the full set.

Power-Ups and integrations to rebuild or drop

Trello Power-Ups, calendar views, Butler automations and third-party connectors do not move into Deck as working features. Export a list of every Power-Up and automation per board, then decide for each one whether Deck can cover the need natively, a Nextcloud app or workflow can replace it, or the team will stop using it. Attachment links and comments are carried over as described in the import documentation, but the integrations that created them are not. Confirm the list with the board owners before the cutover date.

The migration sequence from inventory to decommission

This sequence moves Trello boards into Nextcloud Deck in controlled stages, so each board is inventoried, tested, mapped to real users and verified before Trello is retired. The end result is a documented cutover and a Trello backup that the organization can retrieve later.

Inventory every board and its action count
Start by listing every Trello board the team owns or uses, including archived boards, the workspace or team each belongs to, its member count and whether it has attachments. For each board, record the approximate number of actions, since the Nextcloud Deck documentation sets 1,000 actions as the threshold between the JSON file route and the Trello API route. Assign an owner to each board who can confirm whether it still matters. The output is a board inventory spreadsheet with one row per board, a chosen import route and a retain, migrate or archive decision. The step is done when the board owners have signed off on that list.
Run a pilot import of one busy and one simple board
Pick one board with heavy activity and one simple board, then import both into a test Nextcloud instance using the occ deck:import command or the Trello API route, as the inventory dictates. Check that card titles, lists, labels, due dates and checklists look right, and that comments longer than 1,000 characters appear as attached files and that the Markdown table of attachments sits at the end of each card description. Compare a sample of cards against Trello side by side. The output is a pilot test report listing what matched, what was missing and the fixes applied. The step is done when the board owners and an administrator sign off on the pilot in writing.
Build the user mapping file
Create the configuration file that maps the owner and each Trello user to a Nextcloud user, as the Deck import process requires. Confirm each mapping with the person it refers to, and check that every Trello member who created or commented on cards has a matching account or an agreed fallback owner. If you use LDAP or Active Directory with Nextcloud, confirm that the matched users can log in with their directory credentials before import. The output is a reviewed mapping file kept under change control, with a list of unmatched users and the decision taken for each. The step is done when no board depends on an unresolved mapping.
Operate a parallel run with both tools
Move the pilot boards into production Deck and let the teams work in both tools for an agreed period, with Trello still authoritative for the boards in scope. Record any card that is updated in one tool and not the other, and decide which tool is the source of truth for each board. Keep the import route and mapping file unchanged during this phase so that results stay repeatable. The output is a parallel run log with discrepancies, their causes and the corrections made. The step is done when the board owners agree that the Deck copies match the work in progress.
Write and rehearse the cutover runbook
Document the cutover as a runbook with an ordered list of steps: freeze new work in Trello for the affected boards, take the final export, run the final import with the approved mapping file, verify card counts and attachments against the export, announce the change to members and update any links or bookmarks. Name the person who runs each step and the person who can stop it. Rehearse the runbook once on a copy of the data. The output is an approved runbook and a rehearsal record. The step is done when the rehearsal results match the expected checks.
Execute the final import and cutover
During the agreed freeze window, take the final Trello export or run the final API import, load it into production Nextcloud Deck, and run the verification checks from the runbook. Confirm card counts per list, comment and attachment handling, user ownership and access permissions for each board against the inventory. Switch the team to Deck and set Trello boards to read-only or closed according to the runbook. The output is a cutover record with the verification results and the signed approval from the board owners. The step is done when every board in scope passes its checks.
Decommission Trello after a verified backup
Before removing access to Trello, export the data you need to keep, store it in your own retained archive, and test that it can be opened and searched. Keep the Trello export files together with the mapping file and the cutover record so an auditor or a future administrator can trace how each board moved. Only after the archive check passes should you cancel Trello seats or remove members. The output is a retained archive with a restore check and a decommission record. The step is done when the organization can show that the historical data remains available outside Trello.

How the occ deck:import command handles comments and attachments

The import runs in two stages. First, you write a configuration file that maps the Trello board owner and each Trello member to a Nextcloud user, so cards land under the right accounts. Then you run occ deck:import on the Nextcloud server as the web server user, pointing it at that file. Nextcloud Deck documents both the API and command-line routes, and the exact flags and configuration keys can change between releases, so confirm the syntax against the current Nextcloud Deck user documentation before you run anything on production. Test the mapping on a copy of the board first, because a wrong owner mapping is the easiest error to miss and the hardest to clean up later.

Comments follow a length rule. Trello comments longer than 1,000 characters are not written into the card body. Instead, they are placed on the card as attached files, so a long discussion becomes a file you open from the card rather than text in the activity stream. Trello attachments and attachment links are not uploaded as Deck attachments in the same way. They appear as a Markdown table at the end of the card description, listing each file or link. Plan for this: if your team relies on attachments being browsable inside Deck, check whether the imported links still resolve for the people who need them, and decide whether any critical files should be re-uploaded manually.

After each import, run a short verification pass. Compare the number of boards, lists and cards in Trello with what Deck shows, and sample cards that have long comments, many attachments and archived status. Confirm that each card's owner and assignees match your mapping file and that users outside the mapping are not orphaned. Open a sample of attachment links from a non-admin account to confirm access follows your sharing rules. Keep the configuration file, the import log and your Trello export together, so a repeat import or an audit question can be answered from records. Note that the JSON route only brings up to 1,000 actions, so comments older than that window may be missing from the source data regardless of how the import runs.

How the migration changes by board size and starting point

A small team with a handful of boards usually fits the JSON path. Each board is exported from Trello as a JSON file, and the Deck import reads that file with the occ deck:import command. The file carries up to 1,000 actions, so the work is mostly preparation: list the boards to move, confirm each one is under the action limit, and decide who owns each board in Nextcloud.

Board inventory: List each board, its members and its approximate activity so you know which boards sit near the 1,000-action limit.
User mapping: Prepare the configuration file that maps the board owner and each Trello member to a Nextcloud user before running the import.
Single import run: Run one import per board and keep the output log so every card can be traced back to its source board.
Attachment review: Check the card descriptions for the Markdown table of attachments and attachment links, then confirm the linked files are still reachable.
Long comments: Look for comments over 1,000 characters, which are stored as attached files on the card rather than as inline text.

Before you cut over, open a sample of cards on each board and compare the comment count and the attachment list against Trello. Confirm the Nextcloud user mapping matches your directory before inviting the team.

What usually goes wrong in a Trello to Deck migration

Most Trello to Deck problems come from data that never arrives, users who do not match, and a project that outlasts the cutover date. Each risk below has a check to run before the board goes live.

Incomplete history from JSON exports

A Trello JSON export carries up to 1,000 actions per board. On a busy board, older comments, moves and activity fall outside that window, so cards may look thinner in Deck than they did in Trello. Before choosing the JSON route, count the actions on each board. If a board is near or above the limit, plan the Trello API import with an API key, token and board ID instead, and compare card counts and comment counts after the run.

Users who do not map

The import configuration maps the board owner and each Trello user to a Nextcloud account. A Trello member with no matching Nextcloud user can leave assignments blank or attribute cards to the wrong person. Build the mapping table from a list of Trello members on each board, confirm each Nextcloud account exists and is active, and review a sample of assigned cards after import. Decide in advance who owns boards whose original creator has left.

Attachments that become unreachable

Trello attachments and attachment links are not stored as native Deck files in the same way. The import adds them to a Markdown table at the end of each card description, and links to files hosted by Trello may stop working when Trello access changes. Long comments over 1,000 characters become attached files. Open a sample of cards with attachments and confirm each link and file opens, then download any files you must keep before the Trello plan changes.

Nextcloud version drift

Nextcloud publishes a new major version every four months, and administrators cannot skip major releases during upgrades. If the import runs on one version and production moves to a later one during the project, the import configuration and Deck version may need retesting. Record the Nextcloud and Deck versions used for the test import, check the release schedule before the cutover date, and rerun a small test import on the production version.

Third-party apps blocking upgrades

Apps installed on the Nextcloud server can stop an upgrade if they are not compatible with the target version. The upgrade guidance says to back up before every upgrade and to disable third-party apps until each is confirmed compatible. A migration that adds apps for importing, reporting or automation can therefore delay later upgrades. List every installed app, record its version and compatibility status, and remove any app that is only needed for the import once it is complete.

Teams editing in both tools

If people keep updating cards in Trello after the import, Deck will hold outdated status, comments and due dates while Trello remains the place people look. Set a cutover time, make Trello boards read-only or archive them, and post the new Deck link where people used to find the board. Run one final delta import or manual check for changes made between the first test and cutover, so the last edits are not lost.

What drives the cost and duration of the Deck migration

What are the main cost components of moving Trello boards to Nextcloud Deck?

The cost comes from four components: your internal staff time, the server and storage that run Nextcloud, backups, and any optional paid support or implementation work. Deck itself is part of the open-source Nextcloud Server, so there is no per-user license fee for the community edition. Staff time covers mapping users, reviewing the import, and checking boards with the people who use them. Hosting and backups recur every month. Nextcloud Enterprise is a separate, optional subscription if you want vendor maintenance and support tiers. An implementation partner, if used, is quoted from a written scope. Ask any quote to list each component separately so you can see what is one-time and what recurs.

Which import method and board size change the migration effort?

The import method and the number of Trello actions on each board matter most. Nextcloud Deck documents a JSON file import, which brings up to 1,000 actions, and recommends the Trello API route for boards with more than 1,000 actions, configured with an API key, token and board ID. Boards above that threshold need an API key and token set up by someone with Trello access, and more checking afterward. Count the actions per board before you plan, because that count decides which route each board takes. Ask your implementer to confirm the route per board in writing.

How do attachments and long comments increase migration work?

Attachment volume and comment length add review work and storage. During a Trello import, comments longer than 1,000 characters are placed on the card as attached files, and Trello attachments and attachment links are listed in a Markdown table at the end of the card description. Cards with many files or long discussion threads therefore need spot checks that the files arrived, that links still resolve, and that people can find the content they expect. Storage for the attachments lands on your Nextcloud instance, so total file volume also drives disk size and backup size.

How does the number of users affect the Deck migration?

Each Trello member who owns or appears on imported cards must be mapped to a Nextcloud account. Nextcloud Deck documents an import configuration file that maps the board owner and Trello users to Nextcloud users, so the number of people sets the size of that file and the time spent confirming matches. Teams with shared service accounts, former employees or users with different email addresses need more manual decisions. If you use directory login through LDAP or Active Directory, confirm that the account names match the directory before you map them, because that reduces rework.

Do Trello Power-Ups add effort to the Deck migration?

Yes, when your boards depend on Power-Ups or third-party integrations, because Deck does not reproduce those integrations. Each Power-Up used on a board needs a replacement decision: an alternative Nextcloud app, a small script, a workflow in another tool, or a manual step. List the Power-Ups in use per board during discovery, and ask your implementer to confirm which ones have a Nextcloud equivalent. Boards with few integrations generally move with less rework.

What recurring work does Nextcloud maintenance create after the import?

Nextcloud publishes a new major version every four months and supports each one for a year through monthly maintenance releases that address known critical bugs and security problems. Upgrades cannot skip major releases, so you must move one major version at a time, back up before each upgrade, and disable third-party apps until they are confirmed compatible. Plan staff time for this cycle every year, including test instances and app checks. Ask whether any upgrade and monitoring work is included in a retainer or handled in-house.

When is Nextcloud Enterprise worth paying for during a Deck migration?

Nextcloud Enterprise is worth comparing when you need contracted vendor support, longer maintenance lifecycles or clustered instance support. Nextcloud sells Standard, Premium and Ultimate tiers with a 100-user minimum, and list prices start at 71.29, 104.99 and 204.75 euros per user per year respectively for 100 or more users, with lower rates from 200 users, according to Nextcloud's pricing page. Standard includes one year of maintenance, Premium adds a lifecycle of five or more years, and Ultimate adds support up to 24/7. Teams that can run Deck with their own staff may not need it. Confirm current pricing directly with Nextcloud, since list prices change.

What should I ask for in a written quote for a Deck migration?

Ask for a scope that lists each board, its approximate action count, the import route chosen for it, the number of users to map, the attachment volume, and the Power-Ups to replace. Also ask for the deliverables, what is one-time and what recurs, how backups and upgrades are handled, and which items you must provide, such as Trello API credentials or staff sign-off. DeployOpen plans and implements self-hosted platforms in your own infrastructure and works from a written, fixed scope, so request the scope in writing before work starts. Compare quotes on that scope, not on a headline figure.

Running Trello and Deck in parallel before cutover

Set a freeze date for the Trello boards before the first import run, and tell every board member what that date means for their work. The import itself reads a snapshot of the board, so any card moved, commented on or attached after the snapshot will not reach Deck unless you run the import again. Choose the import path first, since a JSON file carries up to 1,000 actions while the Trello API route, configured with a Trello API key, token and board ID, is the documented choice for boards with more than 1,000 actions. Confirm with your own board sizes which route applies, and check the current Deck documentation before you rely on either path.

Decide what happens to work created in Trello during the import window. The simplest rule is that new cards created after the freeze date are re-keyed into Deck by hand, with the Trello link pasted into the description so the original context survives. For a short overlap, run a second import of the same board and compare card counts and comment counts against Trello before you trust the result. Because comments longer than 1,000 characters are placed on the card as attached files, check a sample of long comments after each run, not only the card titles. Re-running an import is safe only if you treat Deck as the target you rebuild, so agree with the team which copy is authoritative before anyone edits in both places.

Keep Trello read-only before decommission rather than deleting anything. Archive the boards in Trello once Deck has passed your reconciliation, and remove members who no longer need access so no new activity starts there. Before any shutdown, keep a backup of the Trello export, including the JSON files and any attachments you exported, in storage your organization controls, and record which export and date it came from. Confirm your retention obligations with your compliance lead before deleting that backup, because archived boards and exports may hold personal data that falls under your own policies.

Questions buyers ask before migrating from Trello to Deck

What does a Trello to Nextcloud Deck migration cost?

The software itself carries no license fee, so the cost is the work: planning, running the import, checking the results, hosting, and ongoing operations. Nextcloud Deck is an app inside Nextcloud Server, which is licensed under AGPL-3.0, so there is no per-user Deck charge. Costs that recur include the servers or cloud accounts that host Nextcloud, backups, patching and upgrades. The main drivers of the one-time cost are the number of boards, how many actions each board holds, whether comments and attachments must be preserved, and how many Trello users must be mapped to Nextcloud accounts. If you want optional paid Nextcloud support, Nextcloud Enterprise is sold in Standard, Premium and Ultimate tiers with a 100-user minimum. Ask any implementation partner for a fixed-scope written quote that lists each cost component separately.

How long does a Trello import into Deck take?

The timeline depends on the scope you agree, not on a fixed duration. The biggest factor is the import method: a JSON export covers up to 1,000 actions per board, while boards with more than 1,000 actions are better imported through the Trello API, which needs an API key, a token and the board ID. Other drivers include the number of boards, the state of your Nextcloud environment, whether a test instance is available, and how much cleanup is needed for owners, labels and archived cards. Plan separate time for a trial import on a few representative boards, review with the card owners, and then run the full import. Confirm the expected duration, the review steps and the acceptance criteria in the written scope before work starts.

What does our internal team need to provide?

Your team mainly provides access, decisions and sign-off. You need an environment where Nextcloud runs, administrative access to create the import configuration, and a list of the Trello boards in scope. Someone must decide who owns each board and card, because the import configuration file maps the owner and Trello users to Nextcloud users. If you import through the API, you need a Trello API key and token with access to each board. Business owners should confirm which boards are current, which are archived and which should not move. Identity decisions also matter: if users sign in through LDAP or Active Directory, the Nextcloud LDAP app must be configured so that mapped accounts match real people. Confirm these responsibilities with DeployOpen in writing before the engagement begins.

Can our own administrators run the Trello import themselves?

Yes, the import is documented and can be run by a Nextcloud administrator with command-line access. Nextcloud Deck documents importing from Trello with either the API or the occ deck:import command, driven by a configuration file. The JSON route is simpler for small boards, while the API route suits busier boards. Self-run imports still need preparation: a test instance, a verified user mapping, a backup before any change, and a clear check of cards after the import. Many teams handle small pilots in-house and bring in outside help for a large or time-bound cutover. Whichever route you choose, the scope, ownership of errors and rollback steps should be written down before anyone runs the command.

Do comments and attachments survive a Trello import into Deck?

Yes, both are carried over, but in a different shape from Trello. During a Trello import, comments longer than 1,000 characters are placed on the card as attached files. Trello attachments and attachment links are added in a Markdown table at the end of the card description. This means long comments and attachments remain reachable from the card, but they will not look like the original Trello activity. Check the source export before you start: the JSON export is limited to the 1,000 most recent actions per board, so older comments may be missing unless you import through the API. Ask your implementation scope to include a sample review of cards with long comments and multiple attachments.

What happens to Trello Power-Ups after the migration?

Power-Ups do not move into Deck as Trello integrations. Deck is a kanban app inside Nextcloud, so Trello-specific add-ons, their data links and their automations need a separate plan. The import brings across boards, lists, cards, comments, attachments and users as the Deck importer supports them. Anything that depended on a Power-Up, such as calendar views, custom fields or external syncs, must be listed during scoping and either replaced with Nextcloud features, handled with a different app or retired. Ask for a written inventory of every Power-Up and automation in use, along with the decision made for each one.

How should we keep Nextcloud Deck upgraded after go-live?

Plan for ongoing upkeep from day one, because the migration is not the end of the work. Nextcloud publishes a new major version every four months and supports each one for a year through monthly maintenance releases. Nextcloud does not allow skipping major releases during upgrades, so administrators must move one major version at a time, back up before every upgrade and disable third-party apps until they are confirmed compatible. Nextcloud 35 was released on 16 September 2026 and reaches end of life in September 2027. Ongoing support, upgrades and testing can be agreed as a retainer, and you should confirm the scope and response expectations in writing.

How DeployOpen scopes and runs a Trello to Deck migration

DeployOpen plans, implements and hands over Nextcloud Deck inside your own infrastructure, including the Trello import path that fits your boards. We agree the scope, the import method and the acceptance checks in writing before work starts, so you know what moves, what stays behind and who checks the result.

How we scope

Inventory every Trello board, its action count and whether it exceeds the 1,000-action JSON limit
Agree whether the JSON file or the Trello API route, with a key, token and board ID, suits each board
Map Trello members to Nextcloud accounts in the configuration file used by the import
Record how comments over 1,000 characters and attachments will be handled in the written scope

How we build

Deploy Nextcloud Deck on your servers or cloud account, with the database and PHP versions you approve
Run test imports with occ deck:import against copies of boards and review card, comment and attachment results
Configure LDAP, OpenID Connect or SAML login where your identity provider requires it, as agreed in scope
Test permissions, sharing and backups before any production board is imported

How we hand over

Document the import runbook, mapping file, board ownership decisions and any manual cleanup steps
Deliver a list of boards imported, skipped or rebuilt by hand, with the reasons for each
Provide a short walkthrough for board owners on where comments and attachment tables now appear
Hand over backup and upgrade procedures so your team can run Deck after the engagement

How we support

Engagements are fixed-scope, so deliverables and acceptance checks are written before work starts
Ongoing support, Nextcloud upgrades and continuous testing are available as a retainer
Ask us to confirm the upgrade path before each Nextcloud major version change in your environment
Request a written quote that follows from your agreed scope, board count and integration needs