# Nextcloud Deck plus Collectives: ClickUp replacement deep dive

_Research current to 24 September 2026. Scope: self-managed Nextcloud Server 35 with Deck 1.19.0 and Collectives 4.7.0, assessed for a small self-hosting-first team._

---

## 📌 Decision summary

**Verdict: Conditional pilot.** This is a strong ownership, licensing, and knowledge-base fit for a small team that accepts operating Nextcloud. The complete stack is source-available under **GNU AGPL-3.0-or-later**: Nextcloud Server, Deck, Collectives, and the required Text editor are all upstream repositories under that license. Deck 1.19.0 and Collectives 4.7.0 are published as stable releases for Nextcloud 35 in the official App Store. [1] [2] [3] [4] [5] [6]

The combination meets the core collaboration need unusually well without a recurring per-seat software licence: Deck supplies shared multi-user cards, permissions, labels, assignments, comments, attachments, advanced search, Kanban, dependencies, Calendar integration, and a **native Gantt view**. Collectives supplies a team-owned, hierarchical wiki whose pages are Markdown files and are edited collaboratively with Nextcloud Text. It supports pages/subpages, rich editing, tables, attachments, page links/previews, comments, version history, full-text search, Markdown download, and Markdown-directory import. [7] [8] [9] [10] [11] [12]

The qualification is important. This is **not** a ClickUp-shaped work-management database. In Deck 1.19.0, the verified built-in task views are **Kanban and Gantt**; no native List or Table task view is exposed in the stable view-mode control. Its hierarchy is `board → stack/list → card`; dependent cards are relationships, not a documented arbitrary parent/subtask tree. Calendar is provided through Deck’s CalDAV/Nextcloud Calendar integration rather than a separate calendar view inside Deck. The team should therefore pilot its genuine work breakdown, imports, Gantt, Calendar, permissions, and mobile/wiki behavior before migration. [13] [14] [15]

> **Bottom line:** Choose this for **self-hosted collaboration with a very good Markdown wiki and competent Kanban/Gantt execution layer**. Do not select it if a native spreadsheet-like task table, configurable List views, deeply nested tasks, portfolio-level roadmaps, or zero-admin operation are non-negotiable.

### Fit at a glance

| Decision dimension | Verified position | Assessment for this team |
|---|---|---|
| Licensing and control | Server, Deck, Collectives, and Text are AGPL-3.0-or-later upstream projects. The official installer supports self-hosting; the apps are installed from the Nextcloud App Store. [1] [2] [3] [4] [16] | **Excellent** for true open-source and data control |
| Recurring seat cost | The self-managed software is distributed as AGPL code; official Enterprise subscriptions are support/service plans starting at **100 users**, not a required per-seat licence to run the community software. [1] [7] | **Excellent**, subject to hosting, backup, domain, and administrator time |
| Tasks and issues | Shared cards have assignments, tags, start/due dates, done/archive state, Markdown descriptions, files, comments, activity, and dependencies. [8] [14] [15] | **Good**, but not a full issue tracker or custom-work-item system |
| Views and planning | Kanban and Gantt are confirmed in Deck 1.19.0. Gantt supports hour/day/week/month scales and moves card dates. Calendar output is implemented through Deck’s calendar integration. [13] [14] [17] | **Good**, but **no verified native List/Table view**; roadmap/portfolio planning remains limited |
| Wiki and Docs | Collectives pages are Markdown files, hierarchical, collaborative via Text, searchable, versioned, downloadable, and importable. [9] [10] [11] [12] | **Excellent** for a team wiki |
| Permissions and sharing | Deck has explicit ACL capabilities; Collectives is backed by a Nextcloud Team and Nextcloud group/share controls. [8] [18] [19] [20] | **Reasonable**, but page-level role mapping and public-share policy need pilot validation |
| Operations | A self-hosted Nextcloud instance needs a web/database stack or Docker AIO, TLS, upgrades, cron, backups, restore testing, and app compatibility management. [16] [21] [22] [23] [24] | **Material but manageable** for a technically capable small team |

## 🧭 What the solution actually is

This is a **composition of four open-source layers**, not one monolithic ClickUp replacement. Nextcloud Server provides identity, files, sharing, versioning, WebDAV, notifications, apps, and operating controls. Deck is the task/project app. Collectives is the group-owned wiki app. Collectives relies on the Text, Teams, Viewer, and `files_versions` apps; Text is the rich collaborative Markdown editor. [1] [3] [4] [10]

```mermaid
flowchart TB
    accTitle: Nextcloud collaboration stack
    accDescr: A self-hosted Nextcloud server provides identity, storage, sharing, versions, and operations. Deck provides task planning while Collectives and Text provide the group wiki.

    team[👥 Small team] --> nextcloud[☁️ Self-hosted Nextcloud Server]
    nextcloud --> deck[🗂️ Deck: boards, cards, Kanban, Gantt]
    nextcloud --> collectives[📚 Collectives: shared page tree]
    collectives --> text[📝 Text: collaborative Markdown editor]
    nextcloud --> files[💾 Files, versions, WebDAV, sharing]
    nextcloud --> calendar[📊 Calendar / CalDAV]
    deck --> calendar
    nextcloud --> operations[🔧 TLS, updates, cron, backups]

    classDef platform fill:#dbeafe,stroke:#2563eb,stroke-width:2px,color:#1e3a5f
    classDef work fill:#dcfce7,stroke:#16a34a,stroke-width:2px,color:#14532d
    classDef knowledge fill:#ede9fe,stroke:#7c3aed,stroke-width:2px,color:#3b0764
    classDef operations fill:#fef9c3,stroke:#ca8a04,stroke-width:2px,color:#713f12

    class nextcloud platform
    class deck,calendar work
    class collectives,text,files knowledge
    class operations operations
```

The architecture is coherent for this decision context. Work remains on the team’s infrastructure; the same user/group directory governs cards, wiki pages, and files; and documents remain usable outside the web UI through Markdown files and WebDAV. It also means the team inherits a platform, not merely an app: application updates and safe operations apply across the whole server. [3] [9] [20] [21]

## 🔓 Licence, pricing, and free-team viability

### Current licence position

**Verified.** Nextcloud Server’s repository is AGPL-3.0; Deck’s repository says contributions are licensed under GNU AGPLv3 or later; Collectives explicitly states AGPL v3 or later; and Text is AGPL-3.0. The licences satisfy the stated “true open source” requirement rather than offering a source-available exception or feature-restricted community licence. [1] [2] [3] [4]

**Verified.** Neither Deck nor Collectives has a separate paid in-app tier shown on its official App Store listing. Both listings show a current stable build for Nextcloud 35: Deck 1.19.0 and Collectives 4.7.0. [5] [6]

**Careful inference, not a pricing promise.** The official repositories, source-install path, and App Store distribution establish that a team can run the AGPL software itself. The official Enterprise pricing page instead sells subscriptions beginning at **100 users**: Standard from €71.29/user/year, Premium from €104.99/user/year, and Ultimate from €204.75/user/year. It therefore does **not** create a recurring per-user licence requirement for a small self-managed instance. It does mean that commercial support is not realistically priced for a small team at its published starting tier. [1] [7] [16]

### Actual paid gates and limits

| Item | Verified status | Decision implication |
|---|---|---|
| Self-managed Server, Deck, Collectives, Text | AGPL upstream code; Deck and Collectives are installable apps. [1] [2] [3] [4] [16] | No verified per-user licence gate for the requested self-managed stack |
| Enterprise support | Official subscriptions start at **100 users**. [7] | A small team should plan to use community documentation/forum support or buy third-party help, not assume first-party SLA coverage |
| “Additionally supported apps” | The Enterprise price table lists Collectives, Tables, Notes, and several integrations under **Ultimate**. [7] | This is a **commercial support entitlement**, not evidence that Collectives is unavailable to Community users; its public app listing proves it is deployable without Ultimate. [6] [7] |
| Enterprise capabilities | Pricing lists SAML, password policies, audit-ready logging, and workflow handling as Enterprise capabilities. [7] | Do not assume every enterprise-labelled operational feature is present/supported in the chosen Community deployment without a targeted test |
| Storage / seats | Nextcloud user quotas are administrator-configured; no documented Community seat, storage, or task-volume cap was found in the primary sources reviewed. [19] | Capacity is constrained by host storage, backups, database performance, and assigned quotas, not a verified SaaS-style free-tier ceiling |
| Optional platform components | Office, Talk, full-text search, Whiteboard, antivirus, and similar components may add containers, hardware, or commercial cost depending on choices. AIO marks several as optional. [21] | Deck + Collectives need not include all of them; keep the pilot deliberately small |

The real cost is therefore **infrastructure and stewardship**: a domain or private access path, compute and storage, off-host backups, monitoring, patch time, and someone accountable for restore and upgrades. That cost is not a licence fee, but it is not optional in a responsible production installation. [21] [22] [23]

## 📋 Tasks, hierarchy, views, and planning

### Deck capability assessment

Deck is a shared Kanban app with a simple, legible domain model. A board contains stacks (columns/lists), and stacks contain cards. Its official user documentation verifies sharing boards, live collaborative work, labels, user assignments with notifications, due dates, Markdown descriptions, attachments, comments, activity, archive/restore, search, and ownership transfer. Deck’s REST API additionally shows board permissions for read, edit, manage, and share. [8] [18]

Current Deck 1.19.0 adds important planning capability beyond classic Kanban. The release-tagged UI exposes exactly two view modes: **Kanban view** and **Gantt view**. The Gantt component is not a roadmap mock-up: it maps a card’s start and due dates to an editable bar, reports `done` as progress, provides Hours/Days/Weeks/Months scales, opens the card on selection, and writes date changes back to the card. [13] [14]

Deck also has a confirmed `dependentCards` relation. The current UI labels it “Assign dependent cards,” supports adding/removing a card dependency on the same board, and permits marking a listed dependent card done. This is useful for prerequisite tracking and makes the Gantt less superficial. It is **not** evidence of nested subtasks: the card data model has no verified parent-card field, and the relation is named and presented as a dependency. [15]

### Requirement-by-requirement task fit

| Desired capability | Verified availability | Qualification |
|---|---|---|
| Multi-user tasks / issues | **Yes for tasks/cards.** Assign users, share boards with users/groups/circles, comments, activity, and notifications are documented. [8] | Deck cards are tasks. No first-party source reviewed establishes ClickUp-like issue types, custom fields, estimation, sprints, or automation rules |
| Work hierarchy | **Partial.** `Board → stack → card` is verified; Collectives has page/subpage hierarchy. [8] [9] | **No verified nested task/subtask tree.** Dependencies are relationships, not hierarchy. [15] |
| Kanban | **Yes.** This is Deck’s primary interface. [2] [8] | Strong fit |
| List view | **No verified native Deck task List view.** Stable controls expose Kanban and Gantt only. [13] | A hard blocker if a first-class task list is mandatory |
| Table view | **No verified native Deck task Table view.** Stable controls expose Kanban and Gantt only. [13] | A hard blocker if a spreadsheet-like work-item table is mandatory; do not confuse Collectives’ document tables with task-table views |
| Calendar | **Yes, via integration.** Deck has a calendar setting and CalDAV calendar implementation; cards have start and due dates. [17] [14] | Validate the exact Calendar app workflow, delegation, and editing experience in pilot; it is not a separate Deck view documented in the current control |
| Gantt / timeline / roadmap | **Gantt: yes.** Native Gantt is verified in Deck 1.19.0. [13] [14] | No verified portfolio/roadmap, cross-board dependency, capacity, or milestone system. Deck’s board “Activity” timeline is audit history, not a strategic timeline. [8] |
| Filtering and search | **Yes.** Board filters cover tags, assignees, state and dates; global/inline search supports title, description, list, tag, date, and assignee filters. [8] [13] | Good day-to-day retrieval, not a verified analytics/reporting system |

### Calendar and roadmap interpretation

The native Gantt changes this product’s fit materially: it is a practical timeline for cards with dates. It still should be treated as **single-board scheduling**, not evidence of ClickUp’s more general roadmap/portfolio layer. Cards with only one date receive a one-hour inferred span in the source; undated cards are shown separately. The code explicitly limits old tasks by time range to avoid rendering very large ranges. This makes it appropriate for near-to-medium planning, but it reinforces the need to load-test the team’s actual boards rather than extrapolate. [14]

Calendar interoperability is real at the code level, but the decision should not assume ClickUp-style calendar editing until exercised. Deck includes a calendar toggle and server-side calendar implementation, while its stable UI source shows start and due date fields on cards. The recommended pilot should create cards in Deck, inspect them in Nextcloud Calendar, change dates in each direction where supported, and verify access for shared-board participants. [17] [14]

### Performance boundary

Deck’s own README warns that it is not yet ready for intensive usage. Its documented example is a user with 13 boards, each averaging 100 cards and five attachments; file-related queries can reach 6,500 and slow page load. This is not automatically disqualifying for a small team, but it is an explicit upstream capacity caveat. Keep early boards attachment-light, test the largest anticipated board, and decide whether heavyweight files should live in linked Nextcloud folders rather than on every card. [2]

## 📚 Collectives and Docs/wiki assessment

### Information architecture and collaboration

Collectives is built for shared knowledge rather than personal notes. Each collective is backed by a Nextcloud Team, so the content is group-owned rather than owned by one individual. Its user guide verifies an outline with pages and subpages; the editor can link one page to another through a page picker. It also expressly says Collectives can embed task boards, whiteboards, and calendars. [3] [9]

This provides the desired wiki hierarchy. A team can reasonably structure a collective as a handbook or project space, use parent pages for categories, child pages for procedures or decisions, and link pages to Deck boards or task-card URLs. The **embedding claim is verified**, but the docs do not enumerate every provider’s permission behavior; test the desired Deck/Calendar/Whiteboard embeds under actual member permissions. [9]

Collectives supports templates for repeatable pages. The onboarding guide demonstrates creating, managing, and copying a page template, which is useful for decision records, project briefs, postmortems, or meeting pages. [25]

### Markdown interoperability and rich editing

**Verified portable foundation.** Collectives pages are stored as Markdown files, accessible through the Files app in a `.Collectives` folder by default. The folder can be made visible. Nextcloud Text says its files are saved as Markdown and can be edited from other text apps. That is substantially stronger portability than a proprietary-document database. [10] [11]

**Verified import/export paths.** The Collectives administrator guide provides `occ collectives:import:markdown`, importing a directory of Markdown files as pages and attempting to repair relative page links and local attachment paths. It warns that large imports are memory-intensive and may require a higher PHP memory limit. In the current released source, the page action menu always exposes a download link for the Markdown page, and there are download actions for attachments and versions. [10] [26] [27]

**Verified rich editor surface.** Text is a collaborative Markdown editor built on tiptap/ProseMirror. Its upstream test suite confirms an editable table created from pipe-table Markdown, threaded comments with replies and edits, and a Versions sidebar with version comparison. Collectives 4.7.0 explicitly added version comparison on Nextcloud 35; its changelog also confirms attachments, Page previews, search improvements, and an “Export or print” collective action. [4] [12] [28] [29] [30]

| Docs requirement | Evidence-based assessment | Practical caveat |
|---|---|---|
| Collaborative wiki / Docs | **Yes.** Collectives uses collaborative Text editing and group-owned collectives. [3] [4] | Pilot concurrent edits and conflict behavior with real team latency/network conditions |
| Markdown import / export | **Yes.** Pages are Markdown files; download and command-line directory import are verified. [10] [11] [26] | Test a representative corpus with images, links, tables, comments, and embeds. Rich UI elements may need attachment directories or Markdown conventions outside Nextcloud |
| Rich editing | **Yes.** Text provides formatting, Math/LaTeX, tables, and collaborative editing. [4] [28] | It is a focused document editor, not a page-database / Notion-style custom-property platform |
| Tables | **Yes for wiki documents.** A release-maintained Text test renders and edits Markdown tables. [28] | This does **not** supply a queryable table view of Deck tasks |
| Embeds | **Yes, documented for task boards, whiteboards, and calendars.** [9] | Verify providers, public sharing, and permissions before treating embeds as a system-of-record integration |
| Comments / history | **Yes.** Text’s upstream test supports comment threads and edits; Collectives 4.7.0 adds version comparison; Nextcloud versions support restore/download. [29] [30] [31] | Retention is not perpetual by default: old versions expire based on activity/storage policy unless named. [31] |
| Search | **Yes.** Collectives advertises full-text search and its latest changelog records a dedicated search backend and ranking improvements. [3] [12] | Test relevance on actual team vocabulary; do not assume an external enterprise-search appliance is installed |

### Version history and document safety

Nextcloud’s file versioning applies to files and supports rollback/download of prior versions. A version is only created after at least two minutes from the last one, and the platform’s retention policy prunes older versions based on age and available free space. Named versions are excluded from automatic expiration. For an important wiki, backups remain the source of disaster recovery; version history is not a substitute for a retained, off-host backup. [31] [23]

## 🔐 Collaboration, permissions, search, integrations, and mobile

### Permissions and identity

Deck boards use an ACL model with documented `READ`, `EDIT`, `MANAGE`, and `SHARE` permissions. The user documentation says boards can be shared to individual users, groups, and Teams/Circles, with named user permissions taking precedence over group/circle-derived permission. [8] [18]

Collectives is backed by Nextcloud Teams. Teams has Member, Moderator, Admin, and Owner roles. A Member accesses resources shared to the team; Moderator can manage membership; Admin adds team-option configuration; there is a single Owner who can transfer ownership. At server level, administrators can manage accounts, groups, quotas, group admins, and disable/delete users. [3] [20] [19]

This is **reasonable team-level permissioning**, not evidence of an exhaustive page-by-page enterprise ACL hierarchy. The sources reviewed do not give a complete matrix mapping every Team role to every Collectives page action or an approval workflow. The pilot must explicitly test: read-only collaborator, editor, team admin, external/public share, disabled user, and offboarding/ownership transfer. Public Collectives shares require public-share WebDAV access to be enabled; the current app changelog also contains a guest-user behavior fix, so guest/public access should be treated as a controlled exception rather than default collaboration. [10] [12]

### Search and integrations

Deck provides Nextcloud unified search plus inline board search with structured filters. Collectives advertises full-text search and has recently reworked its search backend, ranking, snippets, and public-share handling. This is sufficient evidence for normal retrieval across the two surfaces. [8] [3] [12]

Deck has a documented authenticated REST API, with ETags and update-aware endpoints for boards, stacks, cards, and attachments. Collectives publishes an OCS/OpenAPI specification. Nextcloud also supports WebDAV for files and shares, including Markdown pages, using official desktop/mobile sync clients or third-party WebDAV clients. These are credible integration and portability routes. [18] [3] [32]

Deck’s repository lists Android and iOS Deck companion applications, but those are distinct app projects, not proof of equal feature parity with the web client. Collectives’ official getting-started guide expects a desktop browser; no dedicated Collectives mobile app was verified in the primary sources reviewed. **Pilot the web UI on mobile and offline/file access rather than promising a native wiki mobile workflow.** [2] [9]

### Migration and portability

Deck 1.19.0’s user documentation supports Trello JSON and API imports via API or `occ deck:import`; JSON import is limited to 1,000 actions, while the API is recommended for larger boards. Long comments over 1,000 characters are moved into card attachments, and Trello attachment links are converted into Markdown-table content because Deck does not natively support those links. [8]

The Deck 1.19.0 export UI offers **JSON and CSV**, explicitly saying only JSON can be imported back into Deck. That is a useful board-level exit/migration mechanism. However, test fidelity for assignments, attachments, comments, dependencies, start dates, and activity before treating it as a complete legal/archive export. The modal proves available formats, not semantic preservation for every field. [27]

Collectives is stronger for document portability: pages are file-backed Markdown; they can be downloaded, synced via WebDAV, and bulk-imported from a Markdown directory. Be precise about its limits: imported links and local attachment paths are repaired on a best-effort basis, and rich in-app behaviors such as comments, versions, page metadata, previews, and permissions are not ordinary standalone Markdown semantics. [10] [11] [26] [32]

## 🛠️ Deployment, security, backups, and operations

### Self-host feasibility and dependencies

A normal self-hosted deployment is practical. The stable Nextcloud guide supports 64-bit Linux, Apache or nginx, PHP 8.3–8.5, and MariaDB/MySQL/PostgreSQL; SQLite is only recommended for testing/minimal instances. It recommends at least 512 MB RAM **per process** and says memory needs vary by users, apps, files, and activity. [21]

For the most turnkey official path, **Nextcloud All-in-One (AIO)** is described by its upstream repository as the official installation method. It packages Nextcloud, PostgreSQL, Redis/APCu, client push, a web management interface, updates, optional Borg-based backups, TLS, and other optional components. A classic tarball/LAMP installation is also documented and offers more component-level control. [16] [21]

Deck installs through the Nextcloud App Store or a release package. Collectives installs from the App Store and requires the Teams (or historical Circles), Text, Viewer, and `files_versions` apps; all are stated as shipped/enabled by default in the Server installation. Administrators can restrict apps to specific groups and can manage updates from the Apps page or `occ`. [2] [3] [10] [33]

### Minimum production posture

| Operational control | Verified guidance | Why it matters here |
|---|---|---|
| TLS and safe layout | Nextcloud strongly recommends HTTPS, placing data outside the web root, and can move `config/` outside web root. [24] | Protects cards, wiki pages, attachments, tokens, and database credentials |
| Background work | OS `cron` is the recommended scheduler for multi-user servers; AJAX is least reliable. [22] | Needed for notifications, cleanup, expiration, indexing-related work, and predictable maintenance |
| Authentication | Nextcloud supports pluggable 2FA; administrators can enforce it globally or by group. [34] | Enable TOTP/backup-code policy for administrators at minimum |
| App/update management | App Store installs/updates are admin-managed; app compatibility must be checked against new Server majors. [33] [35] | Pin/validate Deck and Collectives before major upgrades |
| Backup | Retain config, custom apps, data, themes, and database; use maintenance mode to avoid inconsistent snapshots. [23] | Required to preserve Cards (database) and Collectives/files (data store) together |
| Restore test | Nextcloud documents restoration separately and cautions before restoring. [23] | A backup is not a recovery capability until a clean restore is demonstrated |

The hard operational reality is an upgrade cadence. Major Nextcloud releases occur approximately every 16 weeks and maintenance releases every four weeks. Each major is supported for one year; the project advises promptly applying maintenance releases, evaluating app compatibility before major upgrades, and maintaining tested backups. The security policy likewise states one year of security support per major. [35] [36]

### Project maturity and governance

This stack is not an abandoned fork. Nextcloud Server, Deck, Collectives, and Text all have public upstream repositories, AGPL licences, issue trackers, test infrastructure, signed/current releases, and documented contribution processes. At research time, Deck’s official App Store record had been updated within a week and Collectives within two days; both advertised Nextcloud 35 compatibility. [1] [2] [3] [4] [5] [6]

Maturity is mixed rather than uniform. Nextcloud Server is a broad collaboration platform with a mature security policy and release process. Deck is an established app but candidly warns about high-card/high-attachment performance. Collectives is actively releasing and its current release improves version comparison and has recent search, import, attachment, and public-share fixes. The relevant governance risk is **composition risk**: upgrades must preserve compatibility across Server, Deck, Collectives, Text, Viewer, Teams, calendar integration, and any optional apps. [2] [12] [35] [36]

## ⚠️ Hard blockers, risks, and unverified assumptions

### Hard blockers if non-negotiable

1. **A native task List/Table view is mandatory.** Deck 1.19.0 exposes only Kanban and Gantt in its stable view control. Document tables in Collectives do not convert Deck cards into a task database. [13] [28]
2. **Deep task/subtask hierarchy or ClickUp-like work-item types are mandatory.** Deck verifies board/stack/card structure and dependencies, but not an arbitrary task tree, custom issue schemas, portfolios, or advanced workflow configuration. [8] [15]
3. **No one can own infrastructure.** Nextcloud self-hosting requires TLS, scheduled jobs, patching, monitoring, backups, and restore practice. The absence of per-user SaaS fees transfers those responsibilities to the team. [22] [23] [24]
4. **Large attachment-heavy boards are expected without performance testing.** Deck has an explicit upstream warning about query growth in such boards. [2]

### Risks that should be piloted, not assumed

| Risk or assumption | Status | Pilot proof required |
|---|---|---|
| Calendar workflow is equivalent to ClickUp Calendar | **Partially verified.** Deck has calendar plumbing, date fields, and Gantt; editing/permissions UX was not independently executed. [14] [17] | Create, assign, reschedule, complete, and view cards across Deck and Calendar for two users |
| Gantt supplies a portfolio roadmap | **Not verified.** It is a board-level card Gantt. [13] [14] | Try multi-project planning, cross-board dependencies, milestones, and executive status use cases |
| Collectives embeds cover every desired provider securely | **Partially verified.** Docs name task boards, whiteboards, and calendars but do not document every provider/ACL edge case. [9] | Embed a shared Deck board and calendar into a collective for editor/read-only/external roles |
| Markdown is lossless across external editors | **Not safe to assume.** File-backed Markdown and import/download are verified, but comments, attachments, page metadata, and rich previews add platform conventions. [10] [11] [26] [29] | Round-trip a representative Markdown corpus with tables, images, links, comments, and attachments |
| Collectives is a polished mobile wiki | **Not verified.** Official getting-started guidance expects desktop; no dedicated Collectives mobile client was verified. [9] | Test phone browser, official Files client access, offline expectations, and link/embed behavior |
| Guest behavior is straightforward | **Documentation/version caveat.** Admin documentation says guest enablement can allow creating collectives, while the 4.6.1 changelog says guest creation was prevented. [10] [12] | Test the actual 4.7.0 instance with guests disabled by default, then with a controlled guest account |
| Enterprise-labelled features are available free | **Do not assume.** Pricing lists some as Enterprise capabilities/support. [7] | Identify which specific SSO/audit/compliance controls are required and test/price them separately |

## ✅ Recommended pilot scope and exit criteria

Run a **four-week Conditional pilot** with a small production-like group, not a generic feature tour. Use the target stable pairing: Nextcloud 35, Deck 1.19.0, and Collectives 4.7.0. Keep it isolated from a full migration until backup/restore and real workflows pass. [5] [6] [23]

| Pilot workstream | Minimum scenario | Pass condition |
|---|---|---|
| Delivery workflow | One real project with 50–100 cards, labels, two assignments per card, comments, files, start/due dates, dependencies, done/archive states | Team can plan and execute without external task tracker; board responsiveness is acceptable |
| Views | Use Kanban, Gantt, and Calendar with two shared users | Gantt rescheduling is useful; Calendar behavior and permissions meet actual expectations; team formally accepts absence of List/Table |
| Wiki | Import 25–50 Markdown pages with images/tables; create a nested handbook and link/embed work surfaces | Pages, tables, comments, history, permissions, and search meet daily documentation needs; round-trip samples are accepted |
| Access controls | Test member, read-only user, editor, team admin, disabled user, and no public share by default | Least-privilege access works; offboarding does not strand shared knowledge or boards |
| Migration | Import one source board and export it to JSON/CSV; bulk import a wiki directory | Losses are inventoried and accepted; recovery/rollback plan exists |
| Operations | Enable HTTPS, cron, admin 2FA, updates, off-host backup; restore a clean clone | A named operator can restore cards, Markdown pages, attachments, permissions/configuration, and database consistently |

The pilot becomes a **Top pilot** only if the team accepts the task-view and hierarchy limitations, demonstrates a restore, and finds Deck responsive at its real attachment/card density. It should be **excluded** if a native task Table/List surface or true task nesting is required rather than merely preferred.

## References

[1]: https://github.com/nextcloud/server "nextcloud/server — official repository and AGPL licence"
[2]: https://github.com/nextcloud/deck "nextcloud/deck — official repository, features, performance note, licensing, and mobile links"
[3]: https://github.com/nextcloud/collectives "nextcloud/collectives — official repository, collaborative Markdown/wiki features, dependencies, API, and AGPL licence"
[4]: https://github.com/nextcloud/text "nextcloud/text — official collaborative Markdown editor repository and AGPL licence"
[5]: https://apps.nextcloud.com/apps/deck "Nextcloud App Store — Deck releases and compatibility"
[6]: https://apps.nextcloud.com/apps/collectives "Nextcloud App Store — Collectives releases and compatibility"
[7]: https://nextcloud.com/pricing/ "Nextcloud Enterprise pricing, subscription minimums, and support-feature tables"
[8]: https://github.com/nextcloud/deck/blob/v1.19.0/docs/User_documentation_en.md "Deck 1.19.0 user documentation — cards, sharing, imports, search, and ownership transfer"
[9]: https://docs.nextcloud.com/server/stable/user_manual/en/collectives/getting_started.html "Nextcloud Collectives getting-started guide — pages, subpages, linking, and embeds"
[10]: https://docs.nextcloud.com/server/stable/admin_manual/collectives/index.html "Nextcloud Collectives administration guide — dependencies, sharing prerequisites, and Markdown import"
[11]: https://docs.nextcloud.com/server/stable/user_manual/en/collectives/markdown_files.html "Nextcloud Collectives guide — Markdown files in the Files app"
[12]: https://github.com/nextcloud/collectives/blob/v4.7.0/CHANGELOG.md "Collectives 4.7.0 changelog — version comparison, search, Markdown import, attachments, and security fixes"
[13]: https://github.com/nextcloud/deck/blob/v1.19.0/src/components/Controls.vue "Deck 1.19.0 view-mode source — Kanban and Gantt controls"
[14]: https://github.com/nextcloud/deck/blob/v1.19.0/src/components/board/GanttView.vue "Deck 1.19.0 Gantt source — dates, scales, progress, rescheduling, and undated cards"
[15]: https://github.com/nextcloud/deck/blob/v1.19.0/src/components/card/DependentCardsSelector.vue "Deck 1.19.0 dependent-card selector source"
[16]: https://docs.nextcloud.com/server/stable/admin_manual/installation/source_installation.html "Nextcloud Server installation on Linux — deployment choices and manual installation"
[17]: https://github.com/nextcloud/deck/blob/v1.19.0/lib/DAV/Calendar.php "Deck 1.19.0 calendar/CalDAV implementation source"
[18]: https://deck.readthedocs.io/en/latest/API/ "Deck REST API documentation — data model, authenticated API, ACL permissions, ETags, and attachments"
[19]: https://docs.nextcloud.com/server/stable/admin_manual/configuration_user/user_configuration.html "Nextcloud user management — groups, quotas, group administrators, disabling, and deletion"
[20]: https://docs.nextcloud.com/server/stable/user_manual/en/groupware/contacts.html "Nextcloud Teams roles and resource-sharing behaviour"
[21]: https://docs.nextcloud.com/server/stable/admin_manual/installation/system_requirements.html "Nextcloud Server 35 system requirements"
[22]: https://docs.nextcloud.com/server/stable/admin_manual/configuration_server/background_jobs_configuration.html "Nextcloud background jobs — cron recommendation and configuration"
[23]: https://docs.nextcloud.com/server/stable/admin_manual/maintenance/backup.html "Nextcloud backup — required components and maintenance mode"
[24]: https://docs.nextcloud.com/server/stable/admin_manual/installation/harden_server.html "Nextcloud server hardening and security guidance"
[25]: https://docs.nextcloud.com/server/stable/user_manual/en/collectives/onboard_your_team.html "Collectives onboarding guide — team templates and page creation"
[26]: https://github.com/nextcloud/collectives/blob/v4.7.0/src/components/Page/PageActionMenu.vue "Collectives 4.7.0 page action source — page download"
[27]: https://github.com/nextcloud/deck/blob/v1.19.0/src/components/navigation/BoardExportModal.vue "Deck 1.19.0 export modal source — JSON and CSV export formats"
[28]: https://github.com/nextcloud/text/blob/main/playwright/e2e/editor-api-create-table.spec.ts "Nextcloud Text source test — editable Markdown table rendering"
[29]: https://github.com/nextcloud/text/blob/main/playwright/e2e/comments.spec.ts "Nextcloud Text source test — comment references, replies, edits, and deletion"
[30]: https://github.com/nextcloud/text/blob/main/playwright/e2e/versions.spec.ts "Nextcloud Text source test — version browsing and comparison"
[31]: https://docs.nextcloud.com/server/stable/user_manual/en/files/version_control.html "Nextcloud file version control — restore and retention policy"
[32]: https://docs.nextcloud.com/server/stable/user_manual/en/files/access_webdav.html "Nextcloud WebDAV access — standard file synchronization and clients"
[33]: https://docs.nextcloud.com/server/stable/admin_manual/apps_management.html "Nextcloud apps management — installation, group restriction, updates, and app-store controls"
[34]: https://docs.nextcloud.com/server/stable/admin_manual/configuration_user/two_factor-auth.html "Nextcloud two-factor authentication — providers and enforcement"
[35]: https://docs.nextcloud.com/server/stable/admin_manual/release_schedule.html "Nextcloud maintenance and release schedule"
[36]: https://github.com/nextcloud/server/security/policy "Nextcloud Server security policy and supported-version commitment"