See what you can build, analyze, and manage in Tape with an AI assistant connected through the Tape MCP Server.
The goal is inspiration. Use the prompts as starting points and adapt them to your own apps, fields, data, and workflows.
Everyone is invited to contribute. The more use cases, prompts, and ideas we collect here, the more useful this becomes for the whole community.
For setup, tools, and security, see:
Tape MCP Server: Introduction & setup ➔
Good to know
- AI is not deterministic. Running the same prompt twice can produce different results. If a process needs to run the same way every time, use Tape Automations instead.
- AI can make mistakes. Results can be incomplete or incorrect. Verify important findings and changes directly in Tape.
- Watch token usage. Choose the right model for the right task.
- Our setup: All examples below were created with Sonnet 5 and Medium effort.
- Give AI only the access it needs. Limit workspaces, apps, and permissions where possible using Personal Access Tokens.
- Adapt the prompts. These are examples, not templates. Your structure, data, and business rules will be different.
AI-generated results can vary and may not always be complete. For important decisions or changes, review the result directly in Tape.
Build apps from web research
- Researches current information on the web.
- Creates structured apps and records in Tape.
- Relates records to the right teams based on defined rules.
Prompt used in the video
In the workspace `US People Operations`, first create an app called `US Minimum Wage`.
Research the current minimum wage for all 50 US states using official U.S. Department of Labor data.
Create the fields in this exact order:
1. `State`
2. `Review Status` — status
3. `Review Tags` — multi-select
4. `Responsible Team` — relation
5. `Review Batch` — single select
6. `Minimum Wage`
7. `Notes`
8. `Source URL`
Create one record per state.
Next, create a second app called `Compliance Teams` with:
West Region Payroll, Central Region Payroll, East Region Payroll, Compliance Review Team.
Connect `Responsible Team` in `US Minimum Wage` to `Compliance Teams`.
Keep `US Minimum Wage` as the first app in the workspace and keep the field order above unchanged.
Prepare exactly 8 states with:
- `Review Status` = `Needs review`
- `Review Batch` = `September A`
- no `Annual wage review` tag
- not assigned to `Compliance Review Team`
Make sure at least 5 of those 8 already have another review tag.
Create views from a prompt
- Creates complete views with filters, grouping, sorting, and fields.
- Uses the correct operators for each field type.
- Verifies the result afterward without changing records or fields.
Prompt used in the video
In the `Deals` app in Tape, create exactly these two `Team views`. Use only existing fields and field options. Do not create or change fields, options, records, or deal data.
1. `Pipeline by owner` — `Board`: Group by `Deal owner`; group sort `Name` → `Ascending`; enable group `Status bar`; card size `Medium`; cover image `None`; large text `Off`; show only, in this order: `Deal title`, `Deal owner`, `Sale price`, `Expected closing date`, `Primary contact`, `Brokerage`; no filters.
2. `Closing in the next 30 days` — `Table`: Filters combined with `AND`: `Expected closing date` is on or after `Today`; `Expected closing date` is on or before `30 days from today`; `Pipeline stage` is not `Closed - won`; `Pipeline stage` is not `Closed - lost`. Use date operators for `Expected closing date` and option/select operators for `Pipeline stage`; do not use text operators such as `Contains`. Group by `Brokerage`; sort by `Expected closing date` → `Ascending`; show, in this order: `Deal title`, `Deal owner`, `Pipeline stage`, `Sale price`, `Expected closing date`, `Primary contact`, `Brokerage`, `Commission (est.)`.
After creation, verify both views are in `Deals`, both are `Team views`, all filters/operators are correct, `Pipeline by owner` is grouped by `Deal owner`, and no fields, options, records, or deal data were created or changed.
Bulk edit records with AI
- Updates fields across records in one operation.
- Adds values without removing existing ones.
- Reassigns relations based on defined rules.
Prompt used in the video
In the `US Minimum Wage` app, use bulk edit operations across all state records.
- Annual review started: Change `Review Status` to `In review`.
- New review cycle: Add `Annual wage review` to `Review Tags` while keeping all existing tags.
- New review batch: Change `Review Batch` to `Annual Review 2026`.
Our compliance teams have been reorganized. In the existing `Compliance Teams` app, keep the current records and add:
- State Review A–I
- State Review J–M
- State Review N–R
- State Review S–Z
Reassign every state to exactly one new `Responsible Team`, replacing its current relation:
- A–I → `State Review A–I`
- J–M → `State Review J–M`
- N–R → `State Review N–R`
- S–Z → `State Review S–Z`
Do not change any other fields.
Find and consolidate duplicate records
- Finds confident duplicate groups using name and email.
- Consolidates compatible data and relations without silently losing information.
- Sends conflicts to manual review and marks duplicates instead of deleting records.
Prompt used in the video
In the `Contacts` app, perform a non-destructive deduplication of all contacts based on `Name` and
`Email`.
Matching
Find all records that can confidently be identified as the same person based on name and email.
Group all matching records together, not just duplicate pairs.
Do not merge contacts based on name alone when the email addresses indicate different people. If the
match is uncertain, make no changes and add the records to the `Manual Review Report`.
Master record
For each group of matching contacts, use the record that was created first as the master record.
Consolidate all available information from the other matching records into this master record.
Data consolidation
For every field:
- If the master record is empty and another matching record has a value, copy that value to the
master record.
- If multiple records contain the same value, keep it once.
- If the master record already contains a value and another record contains additional compatible
information, preserve both wherever the field supports multiple values.
- If two non-empty values conflict and cannot both be preserved, do not overwrite either value and
do not decide which one is correct. Add the conflict to the `Manual Review Report`.
Example: `Sales Director` vs. `Marketing Director` → manual review required.
No information may be silently overwritten, discarded, or lost.
Relations
Consolidate all relations from every matching record into the master record.
Preserve every unique relation. Before making any change, ensure that no relation to another record
will be lost.
Duplicate records
Do not delete any records.
After all safe data and relations have been consolidated into the master record, rename each
duplicate in the `Name` field by keeping its existing name and appending: `🔴 Delete`
Example: `John Smith` → `John Smith 🔴 Delete`
Manual Review Report
After processing, provide a report of everything that could not be safely consolidated
automatically. For each item show:
- Contact name
- Issue or conflicting field
- Master record value
- Duplicate record value
- Master record URL
- Duplicate record URL
- Reason manual review is required
Use clickable record URLs based on the current Tape environment:
`https://tapeapp.com/{org_slug}/workspaces/{workspace_slug}/apps/{app_slug}/record-v2/{record_id}?view={view_id}&pm=c`
Resolve the actual organization slug, workspace slug, app slug, record ID, and view ID dynamically.
Never hardcode an organization such as `acme-inc`.
Safety rule
This process must be non-destructive. No data or relations may be deleted, overwritten, or lost. If
information cannot be consolidated safely, leave it unchanged and include it in the `Manual Review
Report`.
Build automations with AI
- Reads the app and its existing fields before building anything.
- Creates three different automation patterns based on the actual app.
- Leaves all new automations paused for review.
Prompt used in the video
In the app Deals, build exactly 3 automations, based on this app's own fields - do not invent
fields, statuses or values that are not there.
1. Milestone notification. Pick the status/category field that represents this app's key pipeline
or workflow, and pick one status in it that marks a meaningful milestone (e.g. a deal moving
under contract, an order shipping, an application approved). When a record reaches that status,
send an email to the appropriate mailbox or owner, with the record's title and its most relevant
number field (price, amount, quantity - whatever this app tracks) in the subject and body.
2. Deadline reminder. Pick the date field that represents this app's key deadline (due date,
closing date, renewal date, expiry). A few days before it arrives, add a reminder comment on the
record, but skip records that are already in a finished/closed state - the reminder should only
fire on records still actually in progress.
3. Threshold flag. Pick the number field that best represents this app's stakes (value, amount,
size, priority score). When it changes and crosses a meaningful threshold, use a conditional/
branch action to add a comment flagging the record for extra attention - do not fire the comment
unconditionally, gate it on the actual condition.
For all 3: use real action blocks with proper labels (send email, add comment, conditional) rather
than one custom-code script standing in for everything. Create them in the app as automations, left
paused - do not activate any of them.
Name each one so the title alone tells a human what it does: which change or condition triggers it,
and what it concretely does as a result - not a generic label like "Send notification" that could
mean anything. Use a hierarchical numbering scheme in the title, `[Number] [Trigger] → [Outcome]`,
e.g.:
`1-0-0 Status changed to <milestone> → Send email`
`2-0-0 <Deadline> in <N> days → Add reminder comment`
`3-0-0 <Value field> above <threshold> → Flag record`
Once all 3 exist, tell me what each one does and which field/status/threshold you picked and why.
Do not activate anything without me confirming.
Rename automations with a naming system
- Reviews every automation in an app.
- Applies a consistent hierarchical naming scheme.
- Changes names only. Automation logic stays untouched.
Prompt used in the video
Review all automations in the `Tasks` app.
Rename automations
Use a hierarchical numbering scheme:
`[Number] [Trigger] → [Outcome]`
Examples:
`1-0-0 Record created → Set default values`
`1-1-0 Status changed → Assign owner`
`1-1-1 Status changed → Send notification`
`1-0-0-1 Record created → Send welcome email`
Keep names short and clear. Group related automations and keep them in a logical order. Keep the automation logic unchanged.
Check field dependencies before deleting a field
- Finds views, calculation fields, and automations that depend on a field.
- Shows the potential impact before anything is deleted.
- Runs read-only and makes no changes.
Prompt used in the video
I want to delete the field `Listing status`. Before deleting it, check what depends on this field.
Check:
`Views`
`Calculation fields`
`Automations`
Present the results in one compact table with these columns: `Type`, `Name`, `Impact`. Use one row per affected item. If a category has no dependencies, show `None found`.
Do not change or delete anything.
Audit automations and runs
- Reviews accessible automations and recent runs.
- Finds potential issues using run data and additional checks.
- Creates a structured Excel report with KPIs, usage data, and trends.
Prompt used in the video
Build an Excel workbook that documents every Tape automation this credential can administrate,
using the Tape MCP server as the only data source.
DATA
1. Fetch every automation with tape-get-automations (page with cursor until has_more is false).
2. Fetch every automation run with tape-get-runs (page with cursor until has_more is false).
Note: Tape only retains about 30 days of runs.
3. Do not guess app or workspace names - resolve them from the automation/run rows themselves,
or by calling tape-get-apps if a name is missing.
4. Treat an automation as broken ONLY if it is ACTIVE (not paused) and its "actions" list is
empty - it has a trigger and can fire, but does nothing. Do NOT use the API's own "broken"
field as the verdict, in either direction: it is unreliable (confirmed case: an automation
with 0 actions read "broken": false via both tape-get-automations and tape-fetch, while
Tape's own UI showed the red "Broken" badge) - report it as extra context at most, never as
evidence. A paused automation with empty actions is deliberately off, not an error - it does
not count. Known gap: a freshly built, active automation with a dead reference but zero run
history yet is invisible to this signal until it either runs once or is checked in the Tape UI
directly - state this as a limitation rather than implying complete coverage.
WORKBOOK STRUCTURE (5 sheets, in this order)
1. Home - title, generated timestamp (UTC), a scope note ("only automations this credential
administrates, not necessarily every automation in the organization"), the AI disclaimer below,
a one-line note on the broken-flag heuristic, then KPI tiles for Automations (total, paused,
broken) and Runs (total, completed, failed, other, failure rate), then a per-app breakdown
table (app / automations / runs / failed).
2. Automations - one row per automation: id, name, app, workspace, paused, broken, trigger type,
trigger detail, filter (as compact JSON), action count, action sequence, description,
created/updated (UTC).
3. Runs - one row per run: id, automation id/name, app, workspace, status, type (manual/regular),
created/started/completed (UTC), duration (ms), waiting (ms), actions consumed, failure reason,
error message, triggered-on record id.
4. Usage - one row per automation, aggregated from Runs: total/completed/failed/other run counts,
manual vs regular counts, average duration, last run (UTC), last status.
5. Daily Trend & Heatmap - a chronological daily table (date, weekday, runs, completed, failed),
then a weekday x hour heatmap (Time rows 12 AM-11 PM, Mon-Sun columns, a Total column and a
Total row) built from every run's created_at_utc, with a 3-color-scale conditional format
(green = low, yellow = mid, red = high) over the grid.
AI DISCLAIMER (place on Home, right below the scope note, styled as a muted warning, exact wording)
"AI can make mistakes. This is an example output, not a certified audit - no accuracy or
completeness is guaranteed. It was generated by an AI model reading Tape through Tape's own MCP
server; AI output is not deterministic, so re-running the same check can surface different or
additional findings, and it can also miss things or misread them. Treat every finding here as a
lead to verify in Tape directly, not as a confirmed fact."
DESIGN (apply identically across every sheet, table, and KPI area)
Format the entire Excel workbook in a clean, minimal, modern style. Apply the same visual system
consistently across all worksheets, tables, charts, KPI areas, and worksheet tabs.
Preserve all data, formulas, links, filters, sorting, chart references, worksheet names, and
workbook functionality. Only improve the visual presentation.
Style: white background, hidden gridlines. Primary text #37352F, secondary text #787774. Clean
sans-serif font, compact layout, generous whitespace. Minimal borders; subtle separators such as
#E9E9E7. Avoid heavy borders, dark fills, gradients, shadows, 3D effects, and default Excel
styling. Keep technical/secondary information visually muted.
Alignment: text/names/titles/labels/descriptions/URLs left; dates/timestamps/short
categories/statuses/compact IDs centered where appropriate; numbers/counts/percentages/durations/
quantities/currencies right. Match header alignment to the data below. Base alignment on the
actual data type, not fixed column names.
Headers: white background, semibold #37352F, subtle light-gray bottom border, no colored fills
unless functionally necessary.
Palette (text / background):
Gray #787774 / #F1F1EF · Brown #976D57 / #F4EEEE · Orange #CC782F / #FAEBDD ·
Yellow #C29343 / #FBF3DB · Green #548164 / #EDF3EC · Blue #487CA5 / #E7F3F8 ·
Purple #8A67AB / #F4F0F7 · Pink #B35488 / #F9EEF3 · Red #C4554D / #FDEBEC
Use colors sparingly and semantically: green = positive/success, red = error/critical,
yellow/orange = warning/review/pending, blue = active/information/in progress, gray =
neutral/secondary/technical. Use other palette colors only for categorization.
Rows and tables: fixed row height for every data row (about 18-22 pt), header rows slightly
taller (about 22-26 pt). Never AutoFit. Never let wrapped or long text increase row height -
disable wrapping for long text, JSON, logs, URLs, descriptions, formulas, and payloads; let long
content clip instead. Apply fixed row heights after all other formatting, and re-check every
sheet at the end. Avoid borders around every cell and strong zebra striping. Freeze header rows.
Preserve filters and sorting.
Charts and KPI areas: white/very light neutral backgrounds, same muted palette, no unnecessary
borders/legends/axes/gridlines/shadows/gradients/3D. Titles and labels in #37352F, gridlines in
#E9E9E7. KPI values large and semibold in #37352F, labels smaller in #787774. Prefer whitespace
over heavy cards or boxes.
Worksheet tabs: subtle tab colors from the same palette only when they help distinguish purpose or
grouping; similar sheets share a color; gray when no distinction is needed; keep the total number
of different tab colors low; never color a tab purely for decoration.
Consistency: adapt formatting to actual content and data types, not fixed sheet/column names.
Keep spacing, typography, alignment, row heights, column widths, and hierarchy consistent across
the workbook. Similar zoom levels across comparable sheets (about 90-100%).
FILENAME AND OUTPUT
Save as an .xlsx with a YYMMDD date prefix (e.g. 260909_MCP_Automations-Export.xlsx), in the same
output location as prior runs. Do not overwrite an older dated export - each run gets its own
dated filename.
FINAL CHECK
Confirm: no data/formulas/links/filters/sorting/chart references/sheet names/functionality were
changed from a bare data dump - only presentation was improved. Confirm long text does not expand
row height anywhere. Confirm the disclaimer and scope note are present on Home. Confirm the
broken-automation heuristic (active AND empty actions - never the raw API flag) was applied.
Run a Tape health check
- Checks calculation fields and automations for potential issues.
- Shows the evidence behind each finding with direct links.
- Creates a Markdown report and an interactive dashboard.
Prompt used in the video
Run a Tape health check for calculation fields and automations via the Tape MCP server, across
every workspace and app the connected token can reach. Use only the Tape MCP tools
(tape-get-workspaces, tape-get-apps, tape-fetch, tape-get-automations, tape-get-runs,
tape-query-records, tape-run-automation, etc.) - no direct REST calls, no guessed endpoints. If
the Tape MCP server isn't connected in this session, say so and stop rather than improvising
another way to reach Tape. Read-only diagnostics by default - do not change, pause, or delete
anything unless a step below explicitly says so and you have the human's go-ahead for that
specific action.
0. Establish the URL building blocks before anything else, so every finding can carry a one-click
link instead of an id to search for. The Tape API never returns a URL for an App or an
Automation - only a Record read/query returns "record_url". So:
- Get one real record_url (any tape-query-records or tape-search call returns one) and extract
the org slug from it - the segment right after "tapeapp.com/", e.g. "acme-inc" from
"https://tapeapp.com/acme-inc/record/...".
- App URL (records/fields of one app):
https://tapeapp.com/{org_slug}/workspaces/{workspace_slug}/apps/{app_slug}?view={default_view_id}
workspace_slug from tape-get-workspaces, app_slug from tape-get-apps, default_view_id = the
entry in that app's "views" (tape-fetch type "app") with is_default: true.
- Automation edit URL, simplest verified form:
https://tapeapp.com/{org_slug}/(home//root-modal:workflow-center/edit-workflow/{automation_id})
The segment before "//" is just whatever page sits behind the modal, not tied to the
automation's app - "home" works with nothing but org_slug + automation_id, no lookups needed.
- Calculation field / "Customize record layout" URL (the field editor - opens straight to the
field list, better than the plain app URL for a calculation-field finding):
https://tapeapp.com/{org_slug}/(workspaces/{workspace_slug}/apps/{app_slug}//full-page-modal:blab-item-customize/{app_id})?view={default_view_id}
Try the "home"-based simplification here too - (home//full-page-modal/{app_id}), no
workspace/app slug or view needed - it is unconfirmed but likely works the same way it does
for automations; fall back to the full form if it 404s.
- Give every finding below its matching link.
1. List all workspaces, then all apps (tape-get-workspaces, tape-get-apps). Note which apps are
type "database" - only those hold Records and Fields.
2. Automations that don't work:
- List every automation (tape-get-automations). Skip anything paused - deliberately switched
off is not an error. Do NOT trust the "broken" field either way: it has been observed reading
false even for an automation Tape's own UI marks "Broken" (a dead field reference in a
filter, with zero run history to catch it any other way). It is not a filter and not a
reliable hint - report it as extra context at most, never as the basis for a verdict.
- Pull automation runs from the last 30 days with status "failed" (tape-get-runs). Group by
automation_id and report: automation name, app, how many times it failed, and the distinct
error_message values.
- Only flag automations with a genuine, evidenced problem: 1+ failed run (with the real error
message), or an active (not paused) automation whose "actions" array is empty - it has a
trigger and can fire, but does nothing, which neither "broken" nor a failed-run search
catches. Duplicate/near-identical automations on the same app are worth a separate mention,
but only when at least one copy is actually failing - a working duplicate is not an error.
- Known gap: an automation with a dead field/reference but no run history yet (freshly built,
never fired) is invisible to every signal above. If time allows, spot-check any active,
unnamed, or clearly-in-progress automation (empty actions, no description) by opening it in
the Tape UI directly - currently the only way to catch this class of failure from outside.
- Optional, only with the human's explicit go-ahead per automation (or per clearly-scoped
group): manually trigger (tape-run-automation) an active automation that has never run in the
retention window, to convert "untested" into "confirmed working" or "confirmed failing". This
has real, irreversible effects - real emails, real record writes, no undo. Read the
automation's actions first (tape-fetch type "automation") and tell the human what it will
do - who it emails, what it writes - before running it. Pick a target record that already
satisfies the filter's absolute conditions (operators like "is", "is_empty",
"is_incomplete"). Automations filtering on "has_changed_to" cannot be validated this way:
Tape requires a genuine change event, so running against a record already in the target state
creates no run at all - the call reports success, but nothing happens, and this looks
identical to an unrelated silent failure. Report those as "could not verify", never as
healthy or broken.
3. Calculation fields that don't work:
- For every database app, read its field list (tape-fetch type "app") and pull every field with
field_type "calculation". Check each field's "script" for problems: dangling operators,
unbalanced brackets/parens, obviously incomplete expressions, or a method/property name typo
(e.g. ".lengt" instead of ".length" - invalid, silently returns undefined).
- For apps with calculation fields, sample a handful of records (tape-query-records,
select_fields = just the calculation fields) and check "unresolved_fields": a calculation
field reported "empty_on_this_page" across every sampled record, combined with a suspicious
script, is a strong signal the field never computes. Tape computes calculation fields
asynchronously and omits an uncomputed one from a record entirely - not null, not empty,
simply absent - so this is the only way to tell "broken" apart from "genuinely has no value".
- Separately flag any calculation field whose script text names a field by a label that no
longer matches that field's current label in the app schema (stale reference - usually still
works, but misleads anyone reading the formula).
- Point-in-time gap: a field added or edited after this check's pass over an app is invisible
until the next run. State this plainly rather than implying the calculation-field list is
exhaustive as of "now" instead of "as of when each app was read".
4. Also check, since it's cheap given what steps 1-3 already read:
- Views referencing fields that no longer exist on the app.
- Relation fields whose "referenced_apps" points at an app the token can no longer see.
- Fields with placeholder/test-looking option labels (e.g. "asdf", "test", "tbd").
- Deactivated users still set as an automation's recipient or as a single_user field's value.
- Any app the discovery step lists but that returns "not found" when read directly - the token
can see it exists but not read it. Report as a coverage gap, not a clean bill of health.
5. Report format - produce BOTH of the following, not just one:
a) A Markdown report: one table per category (calculation fields, automations, other), each row
showing App, Field/Automation, the problem, the concrete evidence used to find it (error
message, run count, or the failing script/reference), and the clickable link built per
step 0. State plainly which categories or apps could not be fully checked (30-day run
retention, unreadable apps, fields/automations that may have changed since the scan) rather
than implying complete, permanent coverage. If any automations were manually run per step 2,
add a short section naming which were confirmed healthy, confirmed broken, or could not be
verified, and why.
b) An interactive HTML dashboard, published as an Artifact, using this design system:
Layout: clean, minimal card-based layout with strong visual hierarchy. Neutral background,
clearly separated content blocks, generous and consistent spacing between sections. No
classic spreadsheet-dashboard styling - no heavy borders, gradients, shadows, or
3D/decorative effects. Rounded containers; where a real card isn't warranted, simulate one
with a subtle fill and a thin border. Keep it calm, compact, easy to scan.
Typography: main text #37352F, secondary/labels/metadata #787774. Semibold for titles,
section headers, KPI values, important labels. Short labels, sentence case. KPI values
visually dominant with a smaller muted description underneath. Monospace only for code,
formulas, payloads, ids and other technical values - never for prose.
Cards: white/very light neutral background, subtle border #E9E9E7, no heavy shadow
(extremely subtle at most), consistent padding, aligned to a clean grid, equal sizes for
comparable KPI cards.
Semantic KPI colors (ink / background), used only for meaning, never decoration:
gray #787774 / #F1F1EF (neutral/secondary) - orange #CC782F / #FAEBDD (warning) -
yellow #C29343 / #FBF3DB (warning, alt) - green #548164 / #EDF3EC (healthy/positive) -
blue #487CA5 / #E7F3F8 (active/informational - also the one accent color for an active
filter/tab state) - purple #8A67AB / #F4F0F7 - red #C4554D / #FDEBEC (critical/error).
Filters/tabs: compact pills or a segmented control, one muted accent color (blue, above) for
the active state, neutral gray for inactive - no strong outlines or bright fills.
Finding cards: a subtle colored accent line or badge for severity/category, neutral card
body, most important information first (severity, title, short explanation), technical
ids/references smaller and muted below that.
Charts, if any: white/neutral background, same muted palette, gridlines in #E9E9E7, no
unnecessary legends/borders/axes/labels, prefer direct labels, as few colors as possible.
Design both a light and a dark variant of this palette (same relationships, adjusted for a
dark ground) so the dashboard reads correctly in either OS theme.
Content: only genuine, evidenced findings - never paused automations, never a duplicate that
happens to work, never a stale-but-functional reference presented at the same severity as an
actual failure. Leave out paused automations, manually-verified-healthy items, and coverage
gaps entirely - don't add a collapsed/secondary section for them either; if the human wants
that detail, it's in the Markdown report. Every finding card carries its clickable link from
step 0. Overall the dashboard should read as one coherent interface, not a set of separate
elements - color only ever carries meaning, everything else stays neutral.
Required disclaimer at the bottom of the page, small and muted, below a divider: AI can make
mistakes. This is an example output, not a certified audit, no accuracy or completeness
guaranteed; it was generated by an AI model reading Tape through Tape's own MCP server; AI
output is not deterministic, so re-running the same check can surface different or
additional findings, or miss or misread something; every finding is a lead to verify in Tape
directly, not a confirmed fact.
Create an Excel report across apps
- Combines data from multiple Tape apps in one report.
- Creates one worksheet per employee automatically.
- Adds a management summary with team totals and KPIs.
Prompt used in the video
Create an Excel report called `Team Workload & Pipeline` using the existing `Tasks` and `Deals` apps.
Create one worksheet per employee who is assigned to tasks or owns deals. Name each sheet after the employee using the name available in Tape.
1. Open Tasks
Show all open tasks that are overdue or due within the next 14 days, plus all open subtasks assigned to the employee.
Include: Task, Type, Parent Task, Due Date, Status. Sort by Due Date, empty dates last. Highlight overdue Due Dates in red.
2. Open Deals
Show all deals owned by the employee except `Closed - won` and `Closed - lost`.
Include: Deal, Company, Pipeline Stage, Value, Close Date. Sort by Pipeline Stage, then Close Date.
3. Management Summary
Create the first sheet called `Management Summary`.
Include: Employee, Overdue Tasks, Open Tasks, Open Subtasks, Open Deals, Pipeline Value. Add team totals.
4. Design
Use a clean, minimal business-report design with white background, subtle gray headers, readable widths, wrapped text, filters, and consistent date and currency formats. Leave missing values empty.
5. Export
Export as a Microsoft Excel `.xlsx` file.
Build an interactive relationship map
- Reads apps and relation fields across the organization.
- Builds an interactive map showing how apps are connected.
- Adds search, navigation, auto-layout, and relationship details.
Prompt used in the video
Build a new, standalone, interactive Tape app relationship map from scratch.
Output location: a new, dedicated project folder — pick a short, descriptive name, do not reuse or write into any existing project.
## Scope
Build ONE interactive canvas: apps as nodes, relation fields as the connecting edges. Nothing else — no field-dependency map, no calculation graph, no second view, no toolbar tabs, no view switcher of any kind. This is a single-purpose tool.
Deliverable: one self-contained HTML file that opens by double-click or from any static web server, with no runtime network calls. Inline every library it needs (a component framework, an interactive node/edge canvas library, an auto-layout library) — do not rely on a CDN or a build step at open time.
## Data: active apps and workspaces only
Before extracting anything, determine from the live Tape API whether an app or workspace can be archived/deleted while still being returned by `tape-get-apps` / `tape-get-workspaces`. If either tool exposes a status, archived flag, or trash state, filter it out. If neither tool exposes such a field, state that explicitly — do not assume "returned by the list call" already means "active" without checking, and do not silently drop entries on a guess. Report in the build output exactly how many workspaces/apps were excluded and why, or that none were, and on what evidence.
Use only:
- `tape-get-workspaces`
- `tape-get-apps`
- one `tape-fetch type=app` per database app
Only apps of type `database` can hold a relation field — exclude `form` and `dashboard` apps, they carry no fields relevant to this map.
Never fetch the same workspace or app twice. Cache responses during the run. Use real Tape ids for everything — never invent an id or a relation. Keep the extracted data (apps, workspaces, relation fields) in its own file, separate from the rendering code, so it can be regenerated without touching the UI.
## Design and layout bar
This must ship visually finished, not a working draft. There is no existing design system to reuse, so define one and apply it consistently:
- A small set of design tokens (background, surface, border, text — primary/secondary/muted, one accent color) used everywhere, no ad hoc colors.
- One consistent type scale and spacing scale across toolbar, cards, and panel.
- Calm, neutral, light-mode UI: white/near-white surfaces, thin borders, no gradients, no heavy shadows.
- Auto-layout (e.g. dagre) must produce zero overlapping nodes and zero overlapping edge labels at the default zoom, for the given data set.
- Verify at three zoom levels (fit view, 100%, and zoomed into a single cluster) that nothing clips, overlaps, or becomes illegible.
- No dead space dominating the canvas after "Fit view" on first load.
- Hovering an app highlights it, its neighbours, and its relation fields; everything else fades — no jarring jumps.
- Clicking an app opens a compact side panel: workspace, incoming/outgoing counts, and every relation field, each row clickable to jump to the connected app. Centering on selection is smooth, not instant.
- Provide drag, pan, zoom, "Fit view", "Auto layout", "Reset layout", and a search box (by app name and workspace name). Manual node positions persist in the browser (e.g. localStorage) across a reload; "Auto layout" and "Reset layout" clear that and recompute.
## Definition of done
- Only the relationship map exists — no other views, no unused files wired into the build.
- Only active, non-archived workspaces and apps appear, with a stated basis for that filtering (see "Data" above).
- One consolidated browser verification pass: renders, no console errors, no unexpected warnings, drag/pan/zoom/Fit view/Auto layout/Reset layout all work, hover and selection highlight correctly, search works.
- Final report: apps found, workspaces found, relation fields found, how many entries were filtered as inactive/archived (or that none were, with why), and confirmation the layout has no overlaps at the zoom levels above.
Try it with your own workflows
Pick an idea and try it with your own Tape setup.
Built something useful with the Tape MCP Server, or have an idea others could benefit from?
Share your use case, prompt, or idea below. The more we collect here, the more useful this becomes for the whole community.
Happy building.