> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rocket.new/llms.txt
> Use this file to discover all available pages before exploring further.

# Comparison guide

> Compare productivity integrations in Rocket.new: Google Workspace, Notion, Linear, Jira, and Confluence for docs, specs, and project management.

export const LlmsDirective = () => <blockquote className="llms-directive">
    For the complete documentation index, see <a href="/llms.txt">llms.txt</a>.
    For a lightweight markdown version of this page, append .md to the URL.
  </blockquote>;

<LlmsDirective />

Rocket supports five productivity integrations. Each covers a different part of your team's workflow. Most teams connect several, but this guide helps you prioritize.

## Quick answer

* For specs, wikis, and team knowledge, use **Notion**.
* For spreadsheets, docs, and calendars, use **Google Workspace**.
* For tickets, projects, and bug reports, use **Linear**.
* For Jira tickets, epics, and sprint boards, use **Jira**.
* For product documentation and knowledge bases, use **Confluence**.

All work in both directions: Rocket reads your existing content to build with real context, then writes generated outputs back into your tools.

## Comparison table

| Capability                  | Google Workspace                                  | Notion                                     | Linear                                          | Jira                                            |
| --------------------------- | ------------------------------------------------- | ------------------------------------------ | ----------------------------------------------- | ----------------------------------------------- |
| **Best for**                | Structured data, specs, calendars                 | Team knowledge, PRDs, content              | Issue tracking, sprints, project management     | Issue tracking, epics, sprint boards            |
| **What Rocket reads**       | Docs, Sheets, Calendar events                     | Pages, databases, wikis, templates         | Tickets, projects, acceptance criteria          | Issues, epics, acceptance criteria, sprint data |
| **What Rocket writes back** | Docs (copy, reports), Sheets (data, SEO metadata) | Pages (briefs, docs, copy banks, handoffs) | Issues (follow-ups, QA tickets, client changes) | Read-only (build from tickets)                  |
| **Content types**           | Text, tabular data, calendar events               | Rich text, databases, relations, embeds    | Issues, projects, documents, labels             | Issues, epics, sprints, workflows               |
| **Real-time data**          | Yes (Sheets, Calendar)                            | Yes (databases, pages)                     | Yes (issues, projects)                          | Yes (issues, sprints)                           |
| **Write-back creates**      | New documents and spreadsheets                    | New pages with structured content          | New issues and project boards                   | N/A                                             |
| **Connection method**       | OAuth                                             | OAuth                                      | OAuth                                           | OAuth (Atlassian)                               |
| **Pricing**                 | Free (personal), paid (Workspace)                 | Free tier available                        | Free tier available                             | Free tier available                             |

## Choosing by use case

### Specs and PRDs your team already wrote

**Connect Notion or Google Docs.** If your PRDs live in Notion, connect Notion. If they live in Google Docs, connect Google Workspace. Either way, Rocket reads the full spec and builds from it directly.

```plaintext wrap theme={null}
Read my PRD at [NOTION_URL] and build the described app with all features, user stories, and data models.
```

### Build from tickets and acceptance criteria

**Connect Linear or Jira.** Point Rocket at a ticket and it reads the title, description, and acceptance criteria, then generates the implementation. Your sprint board becomes your build queue.

```plaintext wrap theme={null}
Build the feature described in [LINEAR_URL]. Read the full requirements and acceptance criteria before generating.
```

### Build from epics and sprint context

**Connect Jira.** Paste an epic URL and Rocket reads all child stories, or reference your current sprint to build the highest-priority work first.

```plaintext wrap theme={null}
Read the Jira epic at [JIRA_URL] and build all the screens and features described in its child stories.
```

### Data in spreadsheets that should drive your app

**Connect Google Workspace.** Rocket reads columns, rows, and data types from your Sheets and generates apps that reflect your real data structure. Pricing matrices, product catalogs, team rosters, and campaign trackers all work.

```plaintext wrap theme={null}
Read my product catalog at [SHEETS_URL] and build a storefront with search, filters, and a detail view for each product.
```

### Write documentation after building

**Connect Notion.** Notion is the best destination for generated docs: project documentation, campaign briefs, content banks, client handoff docs, sales one-pagers, and competitive positioning docs.

```plaintext wrap theme={null}
Create project documentation in Notion covering what was built, every page, section, component, and design decision.
```

### Follow-up tickets created automatically

**Connect Linear.** After building, Rocket populates your board with QA tickets, enhancement requests, and client change requests. Each issue gets a description, priority, and acceptance criteria.

```plaintext wrap theme={null}
Create Linear tickets for all follow-up work from this build: QA test cases, enhancements, and edge cases to handle.
```

### Marketing team reviewing generated copy

**Connect Notion or Google Workspace.** Push generated copy to a Notion page or Google Doc. Your marketing team reviews and approves in the tool they already use.

```plaintext wrap theme={null}
Save all marketing copy from this landing page to Notion for the team to review. Organize it by section.
```

### Connect everything for a complete loop

**Connect all five.** Specs from Notion or Docs inform the build. Jira or Linear tickets define the scope. Rocket generates the app. Documentation flows back to Notion, follow-up tickets flow to Linear, and data exports flow to Sheets.

```plaintext wrap theme={null}
Read the spec at [NOTION_URL], build the feature, then create project documentation in Notion, QA tickets in Linear, and export the content structure to Google Sheets.
```

## How it works

These integrations work in both directions and happen during and after generation, not as a separate export step.

| Direction              | What happens                              | Example                                                                  |
| ---------------------- | ----------------------------------------- | ------------------------------------------------------------------------ |
| **Rocket reads**       | Your existing content informs the build   | Spec in Notion becomes a working app                                     |
| **Rocket writes back** | Generated output flows back to your tools | Generated copy pushed to Notion for review                               |
| **Full loop**          | Both directions in one workflow           | Read ticket from Linear, build feature, create QA tickets back in Linear |

<Divider />

## Browse productivity integrations

<CardGroup cols={3}>
  <Card title="Google Workspace" icon="google" href="./google">
    Read from Docs, Sheets, and Calendar. Write copy and data back.
  </Card>

  <Card title="Notion" icon="book" href="./notion">
    Read pages, databases, and wikis. Write docs, briefs, and copy banks back.
  </Card>

  <Card title="Linear" icon="list-check" href="./linear">
    Read tickets and projects. Write follow-up issues and updates back.
  </Card>

  <Card title="Jira" icon="jira" href="./jira">
    Read issues, epics, and sprint data. Build directly from your board.
  </Card>

  <Card title="Confluence" icon="book" href="./confluence">
    Read product specs and documentation as build context.
  </Card>
</CardGroup>