Slack Canvas vs Quip: Architecture, Parity Map and Migration

Slack Canvas vs Quip: Architecture, Parity Map and Migration

Slack Canvas and Quip are not two independently designed products. Canvas was built directly on the Quip codebase — a deliberately scoped subset of Quip's functionality, not a 1:1 replacement. Former Quip engineer Mihai Parparita documented the shared DOM structure, CSS class names, and Python backend in a 2023 technical teardown, confirming what the internal architecture makes obvious: Canvas inherits Quip's rendering engine but exposes only the features Slack chose to carry forward.

The question for teams planning a migration is not "how do these two products compare" but which parts of Quip survived the transition and which were cut. This guide maps the exact feature boundaries, API constraints, permission mappings, and migration strategies for moving from Quip to Slack Canvas before Quip retires.

Last updated: June 2025

If you're already planning your move, see our step-by-step guide to the official Salesforce migration path. If Slack Canvas isn't your target, our 2027 decision guide covers every viable destination.

How Slack Canvas Shares Quip's Architecture

Slack Canvas is a collaborative document surface that runs on the Quip editing engine, embedded natively inside Slack. It started as a mid-2021 prototype to reuse Quip technology inside Slack's UI.

Parparita's 2023 analysis documented the specifics:

• Network requests to load a canvas include URLs containing quip in the path.
• The DOM structure of a rendered canvas matches Quip's, down to identical CSS class names like .quip-document and .document-content.
• The JavaScript controller powering the canvas editor contains Quip references throughout its minified source.
• Quip's in-product debugging tools still function inside Canvas when enabled.
• On mobile, Canvas rendering uses a web view (mobile_collab.js) — the same hybrid approach Quip uses on iOS — because porting Quip's editor to fully native components was not feasible.

Slack's CPO Tamar Yehoshua stated publicly that Canvas takes Quip's collaborative components and integrates them natively into Slack, and Slack's engineering documentation confirms that Quip's Python-based backend powers both products. The Slack API documentation for canvases reflects this shared foundation in how content objects are structured and validated.

This shared foundation is why the official Quip-to-Canvas migration path can convert standard documents with reasonable fidelity. But shared codebase does not mean shared feature set. Slack designed Canvas as a contextual information surface paired with Slack channels — not as a standalone document and spreadsheet suite.

What Slack Canvas Supports: The Complete Feature Set

Slack Canvas supports a defined subset of Quip's document formatting through a markdown-based content model. The Slack Canvas API documentation lists every supported element explicitly.

Text formatting

Structure and layout

Canvas tables max out at 300 cells in any row and column combination — a 10×30 table is valid, a 15×21 table (315 cells) is not. Tables support plain text, canvas links, checkboxes, and inline links. They do not support formulas, cell formatting, conditional formatting, or data validation.

Embeds, mentions, and links

Quip's formatting layer goes further in areas Canvas does not cover. Quip supports underline, text color, and highlight formatting — none of which Canvas carries forward. If your Quip docs use color or highlight as semantic indicators, convert that meaning into structure before migration: a callout, a heading, or a label in the text body. Style-only semantics are where migrations start losing signal.

What Was Dropped: The Deliberate Omissions

Canvas does not include Quip's spreadsheets, Live Apps, or third-party integrations. As outlined in our breakdown of what the converter doesn't migrate, these are scope decisions — features Slack chose not to carry forward — not backlog items awaiting implementation. There is no public documentation promising this parity layer later. Do not plan your migration expecting these gaps to close.

Spreadsheets

Quip offered full spreadsheet functionality: over 400 supported formulas and functions, data validation, conditional formatting, cell-level formatting, charts generated from spreadsheet data, and cross-sheet data references. Quip spreadsheets could pull live Salesforce report data directly into cells.

Canvas has markdown tables only. No formulas. No cell formatting. No data validation. No charts. The 300-cell cap means even simple data grids are constrained. Salesforce makes the migration boundary explicit: Quip spreadsheets cannot be converted to Slack Canvas.

Formula coverage by migration target: Quip's function library is large but not fully documented by Salesforce in a public specification. Google Sheets covers the broadest overlap with Quip's spreadsheet functions (SUMIF, VLOOKUP, ARRAYFORMULA, and most statistical functions transfer directly). Excel Online covers comparable core functions but diverges on array formula syntax. Coda replaces formulas with a row-formula model that requires structural rewrites for any cell-reference-based logic. In all cases, formulas referencing live Salesforce data via Quip's native connector must be rebuilt from scratch — no export format preserves that live connection.

If a Quip document's business value depends on formulas or spreadsheet behavior, flattening it into a Canvas table is a downgrade, not a migration.

Live Apps

Quip's Live Apps were interactive, embeddable applications that ran inside documents. Salesforce launched Live Apps at Dreamforce 2017, covering both first-party and third-party integrations. The following have no Canvas equivalent:

• Kanban Board (@kanban) — drag-and-drop task cards organized in columns
• Calendar (@calendar) — collaborative event planning embedded in documents
• Project Tracker (@project tracker) — list-view task management with columns and fields
• Poll (@poll) — inline team voting
• Countdown (@countdown) — milestone timers
• Process Bar — stage-tracking visualizations
• Salesforce Record (@salesforce record) — live, editable CRM records embedded in documents
• Salesforce List View — customizable list views pulled from Salesforce
• Jira embeds — linked Jira tickets with live status
• Lucidchart and other third-party Live Apps — diagrams, charts, and custom integrations built on the Live Apps API

The Live Apps API itself is gone. Custom Live Apps built by partners or internal teams have no migration target in Canvas.

Canvas does support Salesforce data field unfurls — record previews generated using the viewer's Salesforce permissions — but these are read-only previews, not the interactive, editable Salesforce Record Live App that Quip offered.

What a stripped document looks like: When a Quip document containing a Salesforce Record Live App is converted to Canvas, the embedded record is replaced by a static placeholder indicating that the Live App content could not be migrated. No field values are carried over. The Canvas document retains surrounding text and formatting, but the interactive component is gone entirely. This is the concrete meaning of the 35% incompatibility figure Salesforce cites — documents in this category require manual reconstruction of any data surface they previously embedded.

Other missing features

• @date mentions — Quip allowed @date to insert interactive date references that updated contextually. Canvas supports @user and @channel mentions but not date mentions. Salesforce warns unsupported mentions become plain text during conversion.
• Inline annotations — Quip supported comments on text spans, image regions, spreadsheet cells, and Live App elements. Canvas comments attach to highlighted text or sections via Slack's thread model.
• Slides — Quip included a presentation format. Canvas is document-only.

Quip-to-Canvas Permission Mapping

Quip and Canvas use different permission models, and the conversion is not lossless. Salesforce warns that some users may lose or gain access levels during migration. The table below maps the specific role translation.

The most consequential gap: Quip's Document Admin tier does not exist in Canvas. Any Quip user with Admin-but-not-Owner status is elevated to Canvas Owner during conversion. Audit your Quip permission lists before migration if the distinction between admin and owner carries access-control significance in your organization.

Quip's group-based sharing (sharing a document with a Quip workspace or folder group) also has no direct Canvas equivalent. Canvas access is granted per user or per Slack channel — not to abstract groups. Group-shared documents require explicit per-user access grants during migration, which adds significant overhead for large organizations.

Salesforce's own Quip-to-Canvas FAQ confirms permission fidelity and comment fidelity are separate QA items in your migration validation.

How Do Collaboration and Comments Differ?

Canvas uses Slack's native collaboration model instead of Quip's document-level threading. This aligns Canvas with how teams already communicate in Slack rather than reproducing Quip's standalone document paradigm.

In Quip, every document had a persistent chat sidebar. Comments could target specific text selections, image regions, spreadsheet cells, or Live App elements, and the conversation lived alongside the document permanently. That annotation model carried geometry and cell context that a Canvas comment does not natively model.

In Canvas, collaboration maps to Slack's existing patterns:

• Comment-only access: Users can add comments and emoji reactions, edit or delete their own comments, but cannot modify the canvas content.
• Edit access: Users can modify content, add comments, and grant others view or edit access.
• Owner controls: Canvas owners can grant and revoke access, limit sharing, and delete the canvas.
• Thread-based comments: Comments follow Slack's thread model — threaded discussions attached to highlighted text or sections.

The key migration implication: Quip's document-level chat history does not transfer to Canvas. Comment threads, conversation context, and historical discussions attached to Quip documents are lost. If regulatory or compliance requirements mandate preserving comment history, you need an archival step before migration — export Quip document threads via the Quip Automation API's thread endpoints before the read-only window closes.

What Are the API and Automation Constraints?

The Slack Canvas API is a usable but constrained automation target. As we cover in our migration at scale scripting guide, the canvases.edit endpoint enforces hard limits that directly impact bulk migration strategies.

• Document size: Each document_content object is limited to 1 MiB (1,048,576 characters). This limit applies to each individual change in the changes array.
• Operations per call: Only one operation per API call is currently supported.
• Rate limit: Tier 3 — 50+ requests per minute (this is the floor; actual sustained throughput depends on workspace size and concurrent callers).
• Block Kit: Not supported inside canvases. Canvas content uses markdown only.
• Free teams: Cannot edit standalone canvases (only channel canvases on paid plans).

While 1 MiB of plain text is substantial, this limit is quickly consumed by complex documents containing base64-encoded images, deep column layouts, or repetitive formatting tags. Migration pipelines must include a chunking mechanism to handle oversized documents — splitting them across multiple canvases.edit calls using insert_after operations.

Understanding the payload structure

The canvases.edit endpoint accepts an array of changes. Each change specifies an operation (such as insert_at_end or replace) and a document_content object containing markdown. Because Canvas uses a proprietary flavor of markdown, your migration middleware must translate Quip's HTML-based export format into this specific structure.

Quip export format: Quip's Automation API exports documents as HTML with proprietary structural elements. Column layouts are represented as nested <div> tags with Quip-specific classes (e.g., <div class="quip-column-container">). Embedded spreadsheets export as separate HTML tables with cell metadata in data attributes. Live App content exports as placeholder <div> elements with a data-quip-app-id attribute and no content — confirming that app state is not recoverable from the export.

{
  "canvas_id": "F1234ABCD",
  "changes": [
    {
      "operation": "insert_at_end",
      "document_content": {
        "type": "markdown",
        "markdown": "## Status\n- [ ] Review migration map\n- [ ] Rebuild unsupported apps elsewhere"
      }
    }
  ]
}

Quip's column layouts are represented in HTML as nested <div> tags with specific Quip classes. To recreate these in Canvas, you must parse the HTML AST (Abstract Syntax Tree), identify the column nodes, and transform them into Slack's layout markdown syntax. Off-the-shelf HTML-to-Markdown converters will fail to map these proprietary structural elements correctly — you need a parser tailored for the Quip-to-Canvas translation path.

How to Migrate Quip Content to Canvas Programmatically

Migration works through the canvases.create and canvases.edit API endpoints, both accepting markdown-formatted content. The workflow follows a predictable pattern:

1. Export from Quip using the Quip Automation API (requires an active subscription or read-only window access).
2. Transform content from Quip's HTML export format to Canvas-compatible markdown, using a Quip-aware AST parser.
3. Create canvases via canvases.create with the document_content object.
4. Handle overflow by splitting documents exceeding 1 MiB across multiple canvases.edit calls using insert_after operations.
5. Set access via canvases.access.set to replicate sharing permissions, applying the role mapping table above.

# Example: creating a canvas via the Slack API
import requests
 
response = requests.post(
    "https://slack.com/api/canvases.create",
    headers={"Authorization": "Bearer xoxb-your-token"},
    json={
        "title": "Migrated: Q3 Planning Doc",
        "document_content": {
            "type": "markdown",
            "markdown": "# Q3 Planning\n\n**Owner:** @U123ABC\n\n- [ ] Finalize roadmap\n- [ ] Budget review"
        }
    }
)

Handling cross-document links and mentions

Preserving the internal knowledge graph is a major challenge in any document migration. In Quip, users frequently link to other Quip documents or mention colleagues with @name.

For user mentions, your migration script must map Quip user IDs to corresponding Slack user IDs. If the user exists in Slack, output <@U12345678> in the Canvas payload, which Slack renders as a native mention. If the user has left the company and lacks a Slack account, degrade the mention to plain text to avoid API rejection.

For document links, you need a two-pass strategy. Canvas documents generate new unique URLs upon creation. If Document A links to Document B in Quip, you cannot simply copy the link text. First, create empty Canvas shells for every Quip document to generate the new URLs. Second, populate the content while rewriting internal links to point to the new Slack destinations.

Salesforce also notes that bulk document conversion is not currently supported through their in-product flow, that converted Quip docs become read-only in Quip afterward, and that roughly 65% of Quip documents are expected to be compatible with Canvas conversion. The remaining 35% — spreadsheets, Live App-heavy docs, and documents with unsupported formatting — require alternative handling.

For the full migration walkthrough, see our Quip to Slack Canvases migration guide.

How to Classify Content Before Migration

Migrate Quip to Canvas by classifying content, not by exporting everything the same way. The real work is triage.

• Bucket 1 — Plain documents. Notes, playbooks, agendas, policies, FAQs, and lightweight tables. These are the best Canvas candidates and convert with the highest fidelity. Expect near-complete formatting preservation for documents in this category.
• Bucket 2 — Styled documents. Docs using underline, highlight, and text color as semantic markers. Normalize these into headings, callouts, or labels before conversion. Review comments and permissions after cutover.
• Bucket 3 — App-backed documents. Documents embedding Calendar, Kanban, Project Tracker, Salesforce Record, or Jira surfaces. The Live App content will be a blank placeholder in Canvas. Decide whether each embedded object becomes a screenshot/archive, a Slack-native unfurl, or gets moved to a dedicated tool (Jira for project tracking, native Salesforce for CRM records).
• Bucket 4 — Spreadsheets. Export as XLSX via the Quip API and move to Google Sheets, Excel Online, Coda, or Notion databases. Google Sheets handles the broadest formula overlap. Coda requires structural rewrites for cell-reference logic. Do not force-fit spreadsheets into Canvas tables. See our Quip to Coda or Quip to Notion guides.
• Bucket 5 — Identity and access. Account matching is email-based. Unmatched contributors can block conversion. Apply the permission mapping table above before initiating bulk transfer. Quip group-based shares require explicit per-user grants in Canvas.

What Happens to Spreadsheet-Heavy Quip Instances?

Quip spreadsheets cannot migrate to Canvas. Canvas markdown tables lack formulas, cell formatting, and cross-sheet references — the features that make spreadsheets useful.

Practical options for spreadsheet content:

• Google Sheets / Excel Online: Export Quip spreadsheets to .xlsx via the Quip API's export endpoint, then import. Formulas need auditing — Quip's 400+ function library overlaps substantially with Google Sheets (core statistical, lookup, and text functions transfer), but array formula syntax and Quip-specific functions require manual rewriting. Excel Online is comparable on core functions but diverges on array handling.
• Salesforce Reports: If spreadsheets pulled Salesforce report data via Live Data, rebuild those reports natively in Salesforce and link them from Slack channels. The live Salesforce connection is not exportable — it must be rebuilt regardless of migration target.
• Coda or Notion databases: For teams that used Quip spreadsheets as lightweight databases. Coda's formula model is row-based rather than cell-reference-based, so any formula using cross-cell references requires structural redesign.

The honest answer: spreadsheet-heavy Quip instances face a split migration — documents go to Canvas, spreadsheets go elsewhere. Planning for two destinations is more complex but avoids forcing data into a surface that cannot hold it.

The March 2027 Deadline and When Canvas Is Enough

Quip subscriptions cannot be renewed after March 1, 2027. Salesforce confirmed the retirement of all Quip products — Starter, Advanced, and Plus. Your practical deadline is your own subscription term-end date, not the public cutoff.

After your subscription expires, the shutdown sequence is strict:

The API stops accepting requests once logins are blocked. Your effective extraction window is the active subscription period plus the 90-day read-only phase. Do not treat March 2027 as the starting gun. Enterprise migrations require content auditing, transformation scripting, access mapping, and user training. The minimum safe lead time is six months before your subscription expires — and 12 months for organizations with more than a few thousand documents or significant spreadsheet and Live App usage.

When Canvas is the right target

• Your Quip usage is primarily documents — meeting notes, runbooks, onboarding guides, project briefs.
• Your organization already lives in Slack and wants contextual documentation attached to channels.
• You don't rely on Quip spreadsheets, Live Apps, or Salesforce Record embeds.
• You value the shared architecture — the same rendering engine means the highest text-formatting fidelity of any migration target.

When Canvas is not sufficient

• Quip spreadsheets are a core part of your workflow (pipeline models, financial tracking, report aggregation).
• Your team depends on Kanban boards, project trackers, or calendars embedded in documents.
• You need Salesforce Record or Jira embeds with full interactive behavior inside documents.
• Documents exceed the 1 MiB API limit and require complex chunking strategies.
• You need document-level chat history preserved for compliance.
• Your sharing model relies on Quip group-based permissions that have no Canvas equivalent.

The parity map is clear. Canvas carries forward the document layer faithfully. Everything above that layer — structured data, interactive apps, third-party integrations — was intentionally left behind. The shared codebase does not mean full feature parity; it means the text rendering engine survived and everything built on top of it did not.

For a full breakdown of destinations and decision criteria, see our Quip End-of-Life Playbook.