> ## 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.
# Launchpad
> Connect Notion, Linear, Supabase, Google, Airtable, Mixpanel, or Directus so Rocket uses them as the foundation for better builds and smarter research.
export const LlmsDirective = () =>
For the complete documentation index, see llms.txt.
For a lightweight markdown version of this page, append .md to the URL.
;
Launchpad lets you point Rocket at your existing docs, tickets, schemas, or data so it builds apps and produces research grounded in real material instead of a blank prompt.
Every rocket needs a launchpad to launch properly. Without one, it launches from thin air. No structure, no direction. With a launchpad, there is **solid ground**. The launch is more powerful, more precise, more directed.
**Your existing work is the launchpad.** The Notion doc. The Linear ticket. The Google Sheet. The Supabase schema. The Airtable base. The Mixpanel project. The Directus collection. Rocket reads it, extracts intent, and launches from that foundation.
***
## Supported sources
PRDs, product notes, specs, feature lists, strategy docs, meeting notes.
Google Docs (requirements, briefs, RFCs, design docs) and Google Sheets (structured data, metrics trackers, planning sheets).
Issues, projects, epics, feature requests, acceptance criteria, status history.
Bases, tables, records, CRM data, operational records.
Existing schema, tables, field structure, live data for analysis.
Event data, funnels, cohorts, retention metrics, user behavior analytics.
Collections, fields, content models, relational data, headless CMS content.
This is the initial supported set. More connectors will be added in future releases.
***
## How it works
You can reference a source in two ways:
* **Paste a URL** to a Notion page, Linear issue, Supabase project, Google Doc, Google Sheet, Airtable base, Mixpanel project, or Directus instance. Rocket detects the reference automatically.
* **Type `@`** at the start of your prompt, select **Connectors**, then choose from the available connectors:
* **First message:** Notion, Google, Linear, Airtable, Supabase, Mixpanel, or Directus
* **Follow-up messages:** Notion, Google, or Linear
If the connector is not yet linked to your workspace, Rocket prompts you to connect it. If already connected, Rocket reads the source immediately.
Rocket pulls context from the source. For Build tasks, it extracts features, workflows, data shape, and scope. For Solve tasks, it identifies entities, metrics, timelines, and relationships.
Build tasks produce apps grounded in your specs. Solve tasks produce research grounded in your data. Follow-up questions are sharper because Rocket already understands what you have.
***
## Build vs Solve
Launchpad works in two flows. The source material is the same, but Rocket uses it differently depending on what you ask for.
| Flow | What Rocket does with your source |
| :-------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Build** | Reads the source to understand what app to create. Extracts features, screens, workflows, and data models, then generates a complete app that matches your source material. |
| **Solve** | Reads the source to ground research in real material. Cites exact records, references actual docs, pulls real numbers, and produces deliverables anchored in your data. |
***
## Build examples
**Sources:** Notion, Airtable, Google
Rocket reads the event plan from Notion, the speaker database from Airtable, and the sponsorship tracker from Google Sheets. The generated app includes a conference schedule, speaker directory, and sponsorship pipeline.
```plaintext wrap theme={null}
Build an event management dashboard for TechConf 2026. Use my event plan at [NOTION_URL], speaker database at [AIRTABLE_URL], and sponsorship tracker at [SHEETS_URL].
```
**Sources:** Notion (launchpad), Supabase (launchpad + app connector)
Rocket reads product requirements from a Notion PRD and the existing schema from Supabase. The generated app includes submissions, voting, admin moderation, and uses Supabase for live auth and storage.
```plaintext wrap theme={null}
Build a customer feedback portal from this Notion PRD: [NOTION_URL]. Use my existing Supabase project for auth and storage.
```
**Source:** Linear
Rocket reads the full Linear project including issues, statuses, and acceptance criteria. The generated app shows completed work by epic, in-progress items with progress bars, and blockers.
```plaintext wrap theme={null}
Generate a sprint review page for stakeholders from this Linear project: [LINEAR_URL]. Show completed work by epic, in-progress items with progress bars, and blockers.
```
**Sources:** Airtable, Google
Rocket reads two Airtable tables (Clients and Projects) and a Google Sheets billing log. The generated app includes client filters, active projects, team assignments, and a monthly summary chart.
```plaintext wrap theme={null}
Build a client reporting dashboard from my Airtable base at [AIRTABLE_URL] and billing data at [SHEETS_URL]. Show per-client status, active projects, and monthly billing summaries.
```
**Source:** Mixpanel
Rocket reads your Mixpanel project including events, funnels, and cohorts. The generated app includes a real-time event feed, conversion funnel visualization, and retention curves segmented by user properties.
```plaintext wrap theme={null}
Build a product analytics dashboard from my Mixpanel project at [MIXPANEL_URL]. Show key funnels, retention by cohort, and a breakdown of top events over the last 30 days.
```
**Source:** Directus
Rocket reads your Directus collections, fields, and relational structure. The generated app includes a content editor, media library browser, and a publishing workflow with draft/review/published states.
```plaintext wrap theme={null}
Build a content management portal from my Directus instance at [DIRECTUS_URL]. Include a content editor, media browser, and a publishing workflow based on my existing collections.
```
***
## Solve examples
**Source:** Supabase
Rocket reads your audit\_events table, identifies workspaces with declining activity, flags accounts that stopped using key features, and produces a prioritized risk report with retention recommendations.
```plaintext wrap theme={null}
Analyze at-risk workspaces from my Supabase audit_events table. Flag accounts with declining usage over the last 90 days and recommend retention actions.
```
**Source:** Linear
Rocket traces each issue through its status history, identifies blockers, and produces a structured memo with what shipped, what slipped, and recommended next actions.
```plaintext wrap theme={null}
Summarize delivery progress for this Linear epic: [LINEAR_URL]. Include what shipped, what is blocked, and recommended next steps for the team.
```
**Sources:** Google, Notion
Rocket reads competitor feature matrices from Sheets and positioning notes from Notion, then produces a one-pager with win themes, objection handlers, and comparison tables.
```plaintext wrap theme={null}
Create a competitive battlecard using my competitor dossier at [SHEETS_URL] and positioning doc at [NOTION_URL]. Include win themes, objection handlers, and a feature comparison.
```
**Sources:** Airtable, Google
Rocket reads CRM records from Airtable and billing data from Google Sheets, segments accounts by health score, and produces a rollup with per-account recommendations.
```plaintext wrap theme={null}
Produce an account health report from my Airtable CRM at [AIRTABLE_URL] and billing tracker at [SHEETS_URL]. Segment by health score and flag at-risk accounts.
```
**Source:** Mixpanel
Rocket reads event data and funnel metrics from Mixpanel, identifies underperforming features, and produces a report with adoption rates, drop-off points, and recommendations for improving engagement.
```plaintext wrap theme={null}
Analyze feature adoption from my Mixpanel project at [MIXPANEL_URL]. Identify features with low adoption, highlight drop-off points in key funnels, and recommend improvements.
```
**Source:** Directus
Rocket reads all collections and content items from Directus, identifies stale or incomplete entries, and produces a structured audit with recommendations for updates, archival, and missing content gaps.
```plaintext wrap theme={null}
Run a content audit on my Directus instance at [DIRECTUS_URL]. Flag stale items older than 6 months, identify incomplete entries, and recommend content gaps to fill.
```
***
## Solve deliverable formats
When Launchpad is used with a Solve task, Rocket can produce:
* **Memos and briefs** - narrative write-ups that summarize findings and cite exact docs, issues, or rows.
* **PDFs and one-pagers** - shareable summaries for leadership or partners, with claims tied to real source material.
* **Battlecards** - competitive or account-level cards built from Sheets, Notion pages, and Airtable records.
* **Playbooks and SOPs** - step-by-step guides assembled from decision logs, process docs, and operational records.
* **Dashboards and rollups** - structured views over Supabase, Sheets, or Airtable that aggregate real metrics.
* **Research reports** - longer analyses that cross-reference PRDs, issues, docs, and data to answer strategic questions.
Source context is what makes every deliverable defensible. Launchpad gives Rocket something real to cite.
***
## Launchpad vs app connectors
Launchpad and app connectors serve different purposes. Both can appear in the same prompt.
| Intent | What it means | Example |
| :---------------- | :-------------------------------------------------------------- | :----------------------------------------- |
| **Launchpad** | Rocket *reads from* a connector to understand context | "Use this Notion PRD as the requirements." |
| **App connector** | A connector becomes *part of the generated app's functionality* | "Add Stripe payments to the app." |
The same connector can play both roles. For example, Supabase can be your launchpad (Rocket reads the existing schema) and an app connector (the generated app uses Supabase for auth and database) in the same prompt.
Launchpad does not automatically embed the connector into the generated app. It uses the source to understand your intent. If you also want the connector as a live feature in the app, say so explicitly.
***
## Tips for better results
* **Point to the most precise source you have.** A structured PRD produces a better launch than a brainstorm with loose notes.
* **Be explicit about connector roles.** If you want Supabase as your launchpad *and* as a live backend, say both: *"Read my existing schema from Supabase and use Supabase for auth and storage in the app."*
* **Mix Launchpad with app connectors.** Reference a Notion PRD (launchpad) and ask for Stripe payments (app connector) in the same prompt.
* **For Solve, ask a specific question.** The sharper your research question, the more precisely Rocket can use your source material.
* **Make sure the source is accessible.** Connect the relevant connector to your workspace before starting, or Rocket will prompt you during the flow.
***
## What's next?
Start a Build task from a plain-language description.
Run your first research task with Solve.
Connect Notion, Linear, Supabase, Google, Airtable, Mixpanel, and Directus to your workspace.
Browse every connector available for Build tasks.