# saas-platform-teardown

Adopt this skill: https://proskills.md/skills/other/ahmedyehya92-saas-platform-teardown-kit-saas-platform-teardown

Page: https://proskills.md/skills/other/ahmedyehya92-saas-platform-teardown-kit-saas-platform-teardown
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: saas-platform-teardown/SKILL.md
size: 11292
sha: 127b75ecf29c49a49f7eaed7b2a0b7c68e46f57d
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/SKILL.md

```text
---
name: saas-platform-teardown
description: This skill should be used when the user gives a SaaS product's landing page URL, homepage, or name and asks for a full teardown or deep-dive of how the product works across web, desktop, and mobile — including per-platform feature inventories and user journeys, tech stack, pricing/plan mapping, how the platforms integrate and sync (and the business logic behind those choices), hardware integrations, business-scale/revenue signals, and concrete release artifacts per platform — with a structured Markdown report as the deliverable. Trigger on phrases like "research this SaaS", "do a platform teardown of X", "map every feature of this product across web/mobile/desktop", "reverse-engineer how this app works everywhere", or a bare URL plus a request to understand the whole product.
---

# SaaS Platform Teardown

## Role

Act as a product-research engineer producing a due-diligence-grade teardown of
a SaaS product from nothing but its landing page URL. The deliverable is
Markdown documentation good enough that someone who has never seen the
product could explain, to a stakeholder, exactly what it does, on which
platforms, how those platforms talk to each other — and whether the business
behind it is substantial — with enough method transparency that the reader
can tell verified truth from secondhand reconstruction.

## Before starting

Confirm what's available and degrade gracefully rather than stalling:

1. Check for live browser access, in this order:
   a. Playwright MCP tools (`mcp__playwright__browser_navigate`,
      `browser_snapshot`, etc.). If this session started before the server
      was registered, it won't be present — see (b).
   b. `agent-browser` CLI on `$PATH` (`agent-browser --version` via bash).
      Same audit capability, shell-driven.
   If both are absent, tell the user the web audit will be limited to static
   page fetches — no live app exploration — and continue anyway.
2. Check whether `agy` is on `$PATH` (`command -v agy` via bash). If
   present, use Engine B per `references/06-research-sweeps.md` for
   broad/fast-moving research — read that playbook's permissions section
   before the first sweep (a silently-empty answer means a blocked tool,
   not a finished search). If absent — the common case — run the same
   sweeps via Engine A (the built-in web search/fetch tools) per the same
   playbook: slower, sequential, functionally equivalent. Either way,
   follow that playbook's engine-pick rule and record the engine used in
   the report's methodology section.
3. Check for `gh` (useful when the product has public repos) and a
   Wappalyzer-class tech detector (useful for stack fingerprinting). Neither
   is required to proceed.

Never wait on tool availability — note the gap in the final report's
methodology section and move on with the next-best method.

## Phases

Work through these in order. Each phase has its own reference playbook —
read the file with the `Read` tool immediately before starting that phase,
not all at once at the start. This keeps context focused and matches how
this skill was designed to be used.

| Phase | Goal | Playbook |
|---|---|---|
| 0 | Turn the URL into a map of every platform surface, an access plan per surface, and a hardware yes/no | `references/01-intake-and-recon.md` |
| 1 | Live-explore the web app and walk its user journeys | `references/02-web-platform-audit.md` |
| 2 | Document the mobile apps — store artifacts, journeys — or confirm none exist | `references/03-mobile-platform-audit.md` |
| 3 | Document the desktop app — artifacts per OS/arch, journeys — or confirm none exists | `references/04-desktop-platform-audit.md` |
| 4 | Synthesize how the platforms share data/accounts/notifications, map each integration's business objective, and consolidate journey handoffs + personas | `references/05-integration-architecture.md` |
| 5 (parallel/ongoing) | Fan out broad research questions, including revenue/business-scale sweeps | `references/06-research-sweeps.md` |
| 6 | Assemble and write the final report | `references/07-report-assembly.md` |
| conditional | Hardware deep-dive — load ONLY if Phase 0 (or a store-listing permission) finds a hardware touchpoint | `references/08-hardware-integrations.md` |

(Numbering note: reference files are numbered 1–8 against the phases 0–7
they serve — the table above is authoritative.)

Phase 5 isn't sequential — dispatch research sweeps (either engine) as soon as Phase 0 gives you
concrete questions (company facts, funding/revenue signals, app store
presence, integrations directory, pricing), so results are ready by the time
Phases 1–4 need them instead of blocking on them. The hardware playbook is
also not a phase: it rides alongside whichever platform audit covers the
pairing surface (usually mobile), and if there is no hardware, the explicit
"none found" finding from Phase 0 is all the report needs.

Phases 1–3 each walk their platform's user journeys (onboarding/first-run,
the core "aha" task, account & team setup, a churn-risk moment, and any
platform-exclusive flow, persona-tagged) — the journey schema lives in
`references/02-web-platform-audit.md` and consolidates into the report's
user-journeys file during Phase 4.

## Operating rules

- **Self-serve access is in scope; walls are not.** A disposable-identity
  account on a vendor-offered free trial / freemium / sandbox tier is
  sanctioned and preferred. Never provide real payment info, never scrape
  behind a paywall you don't have legitimate access to, never bypass auth,
  rate limits, or bot protection, and stop at any payment-or-ID-verification
  wall. When a surface is genuinely enterprise-gated, switch it to the
  no-credential access ladder (canonical version:
  `references/02-web-platform-audit.md`) — demo videos, sales/conference
  recordings, help-center screenshots, review screenshots, Wayback, public
  API docs. The ladder is the sanctioned method, not a workaround, and
  never includes misrepresenting yourself to sales.
- **Log access methods per platform.** Every platform section of the report
  records which access methods produced its claims, their evidence grades,
  and why each was chosen. This log is how a reader weighs verified truth
  against secondhand reconstruction — omitting it overstates the report.
- **Attribute everything.** Every factual claim in the final report carries
  either a source URL or an explicit "Inferred from X" note. No claim should
  be traceable to nothing but the model's prior knowledge — this product's
  facts as of *today* are what matters, and training data goes stale.
- **Mark confidence.** Use exactly three labels in the report: `Confirmed`
  (directly observed — screenshot, DOM, API response, official doc),
  `Reported` (a secondary source states it — review, forum, press), and
  `Inferred` (deduced from indirect evidence — e.g., same session cookie
  domain across web and desktop implies shared auth backend). Inferences
  show their reasoning, not just their conclusion.
- **Revenue figures carry their method.** Every revenue/business-scale
  number names its source and how it was derived; estimates are labeled
  estimates; bottom-up ranges show their math and assumptions; regulator-
  filed figures replace estimates when they exist. A lone unsourced number
  is worse than no number.
- **Store-listing metadata is the ceiling for mobile binaries.** Never
  attempt APK/IPA extraction, third-party APK downloads, or any binary/DRM
  analysis — store-listing data is sufficient and is the limit.
- **Hardware gets an explicit answer.** Device families with protocols and
  pairing matrix, or a verified "none found (checked where)" — never
  silence.
- **Timestamp it.** SaaS products ship weekly. The report's header must
  record the research date, because "current" claims decay fast.
- **Prefer paraphrase over quotation** in the report body per normal
  copyright practice, even though this is internal research documentation.

## Evidence language

The report uses two orthogonal scales. Do not conflate them:

- **Claim confidence** grades *the claim*: `Confirmed` (directly observed —
  screenshot, DOM, API response, official doc), `Reported` (a secondhand
  source states it, with the source cited), `Inferred` (deduced, with the
  reasoning chain shown).
- **Access-method grade** grades *how the evidence was seen*: `live` /
  `vendor-documentary` / `third-party` / `marketing-render`. The ladder and
  its grades are defined in `references/02-web-platform-audit.md`.

Mapping between them: `live` evidence can support `Confirmed`. The other
three access methods support a claim at most at `Reported` — vendor docs
say, they don't show; third-party and marketing-render material says
somebody says. One reconciliation for fetched vendor-documentary content
(so two runs resolve it the same way): the fetch is a direct observation
of what the source *states* — "the pricing page lists X" can be
`Confirmed` — while the product-*behavior* the prose describes tops out
at `Reported (vendor-authored)`. A claim with no access method behind it
is `Inferred`, with the reasoning chain shown.

## Definition of done

Before writing the final files, verify the draft actually answers all of:

- What does this product do, in one paragraph a non-technical person understands?
- Who is it for, and what does it cost at each tier?
- What can you do on web that you can't do on mobile, and vice versa? Same for desktop.
- Is there a native mobile app, a native desktop app, both, or neither — with sources?
- Can a reader walk the product's five core journeys (onboarding, aha task,
  team setup, churn-risk, platform-exclusive) on each platform — with
  evidence basis, persona tags, and friction noted?
- Do web/mobile/desktop share one account and sync in real time, or are they more separate than the marketing implies?
- For every integration finding, is the business objective it serves stated
  (vendor-cited) or inferred with reasoning shown?
- Is there an explicit hardware answer — device families with protocol and
  platform pairing matrix, or a verified none?
- How big is the business? Revenue/scale figures each with method + source,
  a bottom-up range shown as math, and filed financials used when they exist.
- Are release artifacts complete per platform: desktop per-OS/arch table
  with version history, mobile store metadata per store, and a verified web
  link inventory with exact URLs?
- What's the underlying tech stack, to the extent it's externally observable?
- What does the product integrate with, and is there a public API?
- Does every platform section state which access methods were used and why?
- Where does the confidence break down — what couldn't be verified, and why?

If any of these is unanswered, that's a gap to close or explicitly flag —
not a reason to pad the report with restated marketing copy.

## Output

Follow `references/07-report-assembly.md` for the file-count decision and
exact structure. Write to `./<product-slug>-teardown/` in the current
working directory and present the files — a report that's written but never
surfaced to the user is a wasted teardown.
```

## File: saas-platform-teardown/references/01-intake-and-recon.md
size: 6502
sha: 4d249ba7f9178357ea26b01d924147f519d8afc3
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/01-intake-and-recon.md

```text
# Phase 0 — Intake & Recon

Goal: turn one URL into a dossier of every platform surface the product has,
plus the two triage calls every later phase depends on — how each surface
will be accessed (live trial vs. the no-credential ladder) and whether the
product touches physical hardware — so later phases know exactly what to
audit instead of guessing.

## Steps

1. **Fetch the landing page** (static fetch). Extract:
   - Product name, one-line positioning, target customer
   - Nav/footer links: Pricing, Docs, Changelog/Release notes, Status page,
     Blog, Careers (job descriptions leak tech stack), Integrations/App
     marketplace, "Download" or "Get the app", API/Developer docs, Security
     page, Community/Forum
   - Any explicit platform badges ("Available on the App Store", "Get it on
     Google Play", "Download for Mac/Windows/Linux")

2. **Resolve every platform surface to a concrete URL:**
   - Web app login/signup URL (often different subdomain, e.g. `app.` or `my.`)
   - iOS App Store listing URL
   - Google Play listing URL
   - Desktop installer download links, per OS
   - Public API/developer docs URL
   - Public GitHub org/repos, if any
   - Status page (often `status.<domain>` or a statuspage.io/instatus URL —
     useful later for inferring backend architecture from incident history)

   If a link isn't in the footer, search for it: `"<product name>" app store`,
   `"<product name>" download mac`, `"<product name>" api docs`, etc. Run
   these lookups as research sweeps per `references/06-research-sweeps.md`,
   picking the engine by that playbook's engine-pick rule — the built-in
   web search is the default; `agy`, when installed, fans them out in
   parallel.

3. **Build the complete link inventory — this is the web platform's release
   artifact, not busywork.** A web app "ships" URLs, so the durable record
   of it is an organized inventory with exact URLs, never descriptions of
   where something lives: marketing site, web app/login, signup, pricing,
   docs, API reference, status page, blog, changelog/release-notes page
   (web apps usually have one even without installers), community/forum,
   and public GitHub org/repos. Verify each URL by fetching it — a footer
   link that 404s is itself a finding. Record the inventory in the recon
   dossier; template `01-overview-and-recon.md` mirrors it in the report.

4. **Triage access for every surface (the gating check).** For each surface,
   decide how its audit will get in, and write the per-surface access plan
   into the dossier:
   - **Self-serve free trial / freemium / sandbox → plan to USE IT** with a
     disposable identity. A product with a self-serve tier is not "gated" —
     this is in scope, preferred, and beats every secondhand source. Note
     what signup demands: email-only is fine; card-upfront or ID
     verification is a wall you do not cross (see SKILL.md operating rules).
   - **Demo-on-request / contact-sales-only → flag the surface for the
     no-credential ladder** (canonical version in
     `references/02-web-platform-audit.md`). While you're here, note which
     ladder rungs look promising for THIS vendor: do they run a public help
     center? A YouTube channel? A public changelog? Conference talks?
   - **Public API docs with an open sandbox or spec → usable for
     feature-scope mapping** even without app access.

   Never misrepresent yourself to sales to obtain an enterprise demo — the
   ladder exists precisely so you don't need to.

5. **Hardware touchpoint quick-check — binary outcome, recorded either
   way.** Scan for physical-device touchpoints: device words in marketing
   nav/footer/page copy (terminal, reader, scanner, printer, wearable,
   sensor, kiosk, dongle, beacon, camera, "works with <device>"), hardware
   SKUs or bundles on the pricing page, hardware/setup sections in the docs
   nav, and embedded/firmware roles on the jobs page. Then:
   - **Any hit** → list the touchpoints in the dossier and load
     `references/08-hardware-integrations.md` alongside the platform audits
     (mobile usually owns pairing, but check web and desktop too).
   - **No hit** → record the explicit finding "No hardware integration
     found (checked: marketing nav/footer/copy, pricing SKUs, docs nav,
     jobs page)". Phase 2's store-listing permissions (Bluetooth/NFC/USB)
     act as the second check. Absence is a reportable finding, never a
     skipped check.

6. **Run a tech-stack fingerprint** on both the marketing domain and the app
   subdomain if one exists (they're often different stacks — e.g. a
   marketing site on Webflow/Next.js in front of an app on a completely
   different framework). Use whatever current Wappalyzer-class tool is
   available (CLI, MCP, or a manual look at response headers / script tags
   on the fetched page if no tool is installed). Note the two stacks separately.

7. **Establish company-level facts** via `agy` or `web_search`: founding
   year, ownership, funding rounds with amounts/dates/lead investors (press
   coverage, not just a database page), headcount signal (LinkedIn), and
   category peers — this grounds the "who is this for" framing later and
   costs almost nothing to gather now. **Also dispatch the revenue /
   business-scale sweeps from the search playbook right now** (revenue
   estimators, app-traction estimates, traffic proxy, public-filings check,
   customer-count claims) so the numbers — each with source and method —
   are back by report time instead of being improvised at the end.

8. **Create the workspace** `./<product-slug>-teardown/` and **write the
   recon dossier** — a short scratch file (not part of the final report) at
   `./<product-slug>-teardown/recon-dossier.md` listing every URL and fact
   found above, each tagged with where it came from, PLUS the per-surface
   access plan (step 4) and the hardware-check outcome (step 5). Every later
   phase reads from this instead of re-deriving it.

## Exit criteria

Move to Phase 1 once you can answer: does this product have a web app
(virtually always yes), does it have native mobile apps (yes/no/unclear),
does it have a native desktop app (yes/no/unclear), do you have a URL for
each surface that does exist, how will each surface be accessed (trial /
ladder / hard wall), and does it touch hardware (yes + touchpoints, or
no (+ where you checked). "Unclear" is fine to carry forward — Phases 2 and 3
exist partly to resolve it.
```

## File: saas-platform-teardown/references/02-web-platform-audit.md
size: 10726
sha: baceb09038d76b99dc6ca34b19c458317d4a2dba
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/02-web-platform-audit.md

```text
# Phase 1 — Web Platform Audit

Goal: document what the web app actually does (not what the marketing copy
claims), walk its user journeys end to end, and record exactly how you were
able to see what you saw. This phase leans on live browser access for ground
truth — accessibility-tree snapshots and real DOM/network state instead of
inferring layout from a prompt.

## Browser tooling: pick whichever is actually available

Check in this order and use the first that works — do NOT skip the phase
just because one tool is missing:

1. **Playwright MCP** (preferred). Tools appear as `mcp__playwright__*`
   (`browser_navigate`, `browser_snapshot`, `browser_network_requests`,
   `browser_take_screenshot`, ...). Verify presence before relying on it —
   if a session shows none, run `claude mcp list | grep playwright` to
   check; it should report `✔ Connected`.
2. **`agent-browser` CLI** (fallback, verified installed). Same job,
   shell-based: `agent-browser open <url>`, `agent-browser snapshot`,
   `agent-browser screenshot <path>`, `agent-browser eval '<js>'`.
   It speaks accessibility-tree YAML like the MCP does, so the audit steps
   below translate 1:1 — just batch commands in single bash calls.

   Whichever browser tool is active: drive client-rendered apps by
   CLICK, not keyboard shortcuts — one stray hotkey while focus sits on
   the wrong element can navigate the tab away mid-journey.

3. **Neither** → degrade gracefully: `WebFetch` the public pages, say so.
   Static fetches cannot read JS-rendered surfaces — Play store
   listings, Swagger/OpenAPI UIs, login screens — so route those to
   platform APIs or third-party docs and keep their claims `Reported`;
   explicitly in the report's methodology section, and mark all UI claims
   `Reported` instead of `Confirmed`.

## Getting in: access triage and the no-credential ladder

Try the tiers in order. The ladder below is the CANONICAL version — the
mobile and desktop audits reuse it by reference, because every rung that
yields web screenshots of gated screens tends to yield mobile/desktop
screenshots of the same product too.

**Tier 0 — self-serve account. Always try this first; it is usually
sufficient.** If the vendor offers a free trial, freemium tier, or public
sandbox, sign up with a disposable identity and use it. A product with a
self-serve tier is NOT gated — never jump to secondhand sources while a
live trial is on the table. Two hard stops, per the operating rules: never
provide real payment details (a card-required "free" trial is a wall, not
a door), and stop at ID verification. Even with a live account, the ladder
below stays useful for screens your tier can't reach (higher-plan
features, admin-only areas) — don't pay to see them, reconstruct them.

**If the product is genuinely enterprise-gated / sales-call-only, work the
ladder top-down and log which rungs you used, per platform:**

- **Rung 1 — official motion.** Demo videos, recorded product tours (the
  vendor's YouTube channel, Wistia/Vidyard embeds on their site),
  interactive tour pages (Navattic-style), recorded webinars. Real UI in
  motion, but staged: the vendor chose what you see and what they skipped.
- **Rung 2 — sales & conference material.** Sales-call recordings,
  conference talks, webinar slide decks (vendor events/resources pages,
  YouTube, Speaker Deck, SlideShare). These often walk the exact evaluation
  flows a buyer sees, including admin screens vendors hide from marketing.
- **Rung 3 — help center / knowledge base.** Vendors screenshot gated
  screens in order to explain them. Help articles are usually the single
  richest no-account source, and they're typically sequenced per flow
  (set up your workspace → invite your team → configure X), which lets you
  reconstruct *journeys*, not just screens. Search the help center for the
  flows in the journey list below, article by article.
- **Rung 4 — third-party screenshots.** G2 / Capterra / TrustRadius reviews
  (reviewers embed in-app screenshots), Product Hunt launch threads and
  comments, Reddit and community-forum posts. Unstaged but fragmentary and
  rarely dated — good for corroboration and for friction, weak alone.
- **Rung 5 — employer & ecosystem leaks.** Job postings with product
  screenshots embedded; engineering blog posts walking through internal
  tooling built on the product's own API.
- **Rung 6 — history.** Wayback Machine snapshots of the app itself or its
  docs — partial and dated, and also your tool for pricing/feature
  archaeology ("what did tier 3 include last year").
- **Rung 7 — structure without UI.** Public API / developer docs. The API's
  data model bounds the feature surface: every endpoint and object is a
  feature that exists, and what's absent bounds the scope. No account
  needed, ever.

**Evidence grades the rungs produce** — use these in the access-methods log
and on every reconstructed journey:

| Grade | Produced by | Ceiling for claims |
|---|---|---|
| live | walked in-app (trial/freemium) | `Confirmed` |
| vendor-documentary | help center, official video/webinar, API docs, changelog | `Reported` (vendor-authored) |
| third-party | review screenshots, forums, Product Hunt, Reddit | `Reported` (third-party) |
| marketing-render | landing-page imagery | `Reported` (staged) — weakest; say so when it's all you have |

These grades feed the claim-confidence mapping in SKILL.md's Evidence
language section — a grade records how evidence was seen, a confidence
label records what the claim is worth.

The ladder is the sanctioned answer to "no credentials." It is not a
license to bypass auth, paywalls, or bot protection — never do that, on any
rung, for any platform.

## Steps

1. **Map the navigation** with `browser_navigate` + `browser_snapshot`.
   Record every top-level section, and for each one:
   - What it's for, in one sentence
   - Key actions available (create, import, share, export, automate...)
   - Anything gated behind a higher plan (cross-reference the pricing page)

2. **Test at multiple viewports.** Ask for snapshots/screenshots at desktop
   (≈1440px) and mobile-web (≈375px) widths. Note whether the web app itself
   is responsive — this matters for the integration-architecture phase,
   since "no native mobile app" often means "the web app is the mobile
   experience," which is a real, reportable fact.

3. **Watch the network layer where the MCP tooling allows it.** Note the API
   domain(s) called (e.g. `api.product.com` vs the app domain) — this is a
   primary signal for Phase 4's shared-backend analysis, and for whether a
   public API exists at all (compare against any documented API docs URL
   from Phase 0).

4. **Capture screenshots of 3–6 representative screens** — enough to
   illustrate the product in the final report. Journeys (below) add their
   own decision-point screenshots on top of this baseline set.

5. **Cross-reference pricing.** Fetch the pricing page and map observed
   features to plan tiers. Flag any feature seen in-app that pricing copy
   doesn't mention, or vice versa — these mismatches are useful findings.

## User journeys on web — walk these while access is hot

The report's decision-grade core is journeys, not feature lists. Walk all
five below on web; they are consolidated per platform in the report's
`05-user-journeys.md` and synthesized cross-platform in Phase 4.

1. **Onboarding / first-run** — from signup to the first moment of value:
   everything the product makes you do before you get anything (email
   verification, workspace creation, setup questions), and where it drops
   you afterward.
2. **The core "aha" task end to end** — the primary thing the product
   exists for, performed completely: create → use → see the payoff.
3. **Account & team setup** — inviting teammates, roles/permissions, org or
   workspace creation, identity configuration (SSO hints even when the SSO
   itself is enterprise-gated).
4. **A churn-risk moment** — two variants, both inside the trial's rules:
   (a) deliberately approach or hit a plan limit (seats, rows, runs —
   whatever the free/trial tier caps) and record the paywall UX: what gets
   blocked, what the nudge looks like, how hard the sell is; (b) walk the
   cancellation / delete-account flow all the way to its final
   confirmation and abort there. Never enter payment info to see past a
   wall.
5. **Any web-exclusive flow** — something the other platforms structurally
   can't do: bulk operations, workspace administration, billing, exports.

**Record the same schema for every journey** (the template enforces it):
entry point (exact URL/screen) · steps in order (numbered, what you
clicked) · decision points (branches offered to the user) · handoffs to
another platform (deep links, QR codes, "download the app" prompts —
Phase 4 needs every one of these) · friction points observed · evidence
basis (walked live / reconstructed from which rung) · persona tag.

**Personas:** if the product clearly serves distinct user types (admin vs.
end user vs. viewer vs. billing owner — check the roles offered in team
setup, or distinct navs visible in help-center screenshots), tag each
journey with its persona, and where variants differ (admin's journey 2 vs.
end user's journey 2), walk or reconstruct BOTH and label which is which.

With live access: actually perform each journey; screenshot at each
decision point. Without: reconstruct from help-center article order
(rung 3), demo-video timelines (rung 1 — cite timestamps), and review
screenshots (rung 4). Every reconstructed step is `Reported` with its
source, and the journeys writeup must say "reconstructed" — never imply
"walked."

## Access-methods log (required output of this phase)

Before leaving this phase, fill the web platform's access-methods log
(template `02-web-platform.md`): which methods were actually used, what
each yielded, its evidence grade, and why it was chosen ("self-serve trial
existed" / "enterprise-gated; help center public"). This log is how a
reader weighs how much of the web section is verified truth versus
secondhand reconstruction — a report that omits it is overstating itself.

## What to record per feature

For each notable feature: name, one-line description, which plan tier it
requires (`Confirmed` if seen gated in-app, `Reported` if only pricing copy
says so), and a screenshot reference if captured.

## Exit criteria

You can list the web app's primary navigation, walk (or reconstruct,
labeled as such) its five journeys, state which API domain it talks to,
and point to an access-methods log that says how you know each of those.
```

## File: saas-platform-teardown/references/03-mobile-platform-audit.md
size: 6134
sha: d205e83cdd00bd8676d07ae2ea2178ba5593a91d
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/03-mobile-platform-audit.md

```text
# Phase 2 — Mobile Platform Audit

Goal: establish, with sources, whether native mobile apps exist and — if so
— what they can and can't do relative to web; capture their release
artifacts from the store listings; and reconstruct their user journeys.

The live browser can't drive a native mobile app, and most environments
won't have a device or emulator attached, so this phase works
from store listings, changelogs, reviews, and the no-credential ladder
(canonical version: `references/02-web-platform-audit.md` — same rungs, same
evidence grades). If a device or emulator IS available and the product has
a self-serve free tier, a live install is legitimate and upgrades journey
claims from `Reported` to `Confirmed` — note it in the access log. Default
to the store-listing method.

## Steps

1. **Confirm existence per store.** Search the App Store and Google Play
   directly (`agy` or `web_search`: `"<product name>" site:apps.apple.com`,
   `"<product name>" site:play.google.com`). Absence after a real search is
   itself a finding — report "no native mobile app found" with the search
   terms used, don't just go silent on mobile.

2. **Pull structured listing data — these ARE the mobile release
   artifacts.** Via an app-store review/listing CLI if one is installed,
   otherwise fetch the store page directly:
   - Description and screenshots (what the store screenshots emphasize often
     reveals the mobile-specific value prop, e.g. "scan receipts on the go")
   - Supported OS versions, app size, last update date
   - Permissions requested (Play Store "App info" / "Data safety" section;
     App Store "App Privacy" section) — a strong signal for mobile-only
     capabilities: camera, location, biometrics, contacts, push
     notifications. Also re-run the Phase 0 hardware check here:
     Bluetooth/BLE, NFC, or USB-accessory permissions mean the app pairs
     with physical hardware, whether or not the marketing site said so —
     if this fires and the dossier doesn't already have hardware flagged,
     load `references/08-hardware-integrations.md`.
   - Version history / "What's New" entries — read the last 5–10 to build a
     dated mini timeline and catch recently added mobile-only capabilities.
   - The developer/publisher account name on each listing — if it doesn't
     match the company from Phase 0, that's a white-label or
     agency-built finding worth reporting.

   **Constraints — do not loosen these:** no APK extraction or downloads
   from APK-mirror sites, no IPA acquisition (that's jailbreak /
   enterprise-cert territory), no binary or DRM/protection analysis of any
   kind. Store-listing metadata is the full ceiling for mobile release
   data, and it is sufficient. One legitimate addition: check whether the
   vendor distributes a direct APK / sideload build for enterprise or
   Android-only distribution (their docs or download page); if the link is
   public, capture the link and its context — nothing more.

3. **Read a sample of reviews for feature signal**, not sentiment: users
   frequently complain "I can't do X on mobile that I can do on web" or ask
   for a feature by name. That's free feature-gap data — and each
   recurring complaint is a broken step in some journey; attribute it to
   that journey. Cap this — a representative sample of recent reviews, not
   an exhaustive read.

4. **Reconstruct mobile user journeys.** Same five journey types as web —
   onboarding/first-run, the core aha task, account & team setup, a
   churn-risk moment, and platform-exclusive flows — reconstructed because
   you usually can't walk them live:
   - Store-listing screenshots are often the onboarding sequence in
     disguise: first screens, empty states, permission asks, in that order.
   - Help-center mobile sections (ladder rung 3) document mobile flows
     screen by screen — usually the richest reconstruction source.
   - Review complaints are journey friction data ("forces you to the
     website to manage billing" is a handoff finding AND a friction point).
   - Demo videos (rung 1) frequently show the mobile app inside the
     vendor's cross-platform pitch.

   Mobile platform-exclusive journeys to look for specifically: push-
   permission onboarding, widget setup, offline capture flow, camera/scan
   capture, biometric unlock enablement, hardware pairing (if the Phase 0
   hardware check fired). Record each journey with the same schema as web
   (entry point, steps, decision points, handoffs — mobile journeys often
   hand OFF to web for admin/billing; capture exactly where, Phase 4 needs
   it), friction, and evidence basis. Everything is `Reported` unless a
   live install was performed.

5. **Classify the mobile app's role** against the web app using the recon
   dossier: `companion` (view/notify only), `full parity`, or `mobile-first
   extras` (has capabilities the web app lacks, e.g. widgets, offline mode,
   biometric unlock, camera capture). State which, with the evidence.

6. **If genuinely nothing else is available**, state the conclusion plainly:
   "This product has no native mobile app; mobile access is via responsive
   web only," and note whether that responsive web experience was already
   evaluated in Phase 1.

## Access-methods log (required output of this phase)

Fill the mobile platform's access log (template `03-mobile-platform.md`):
store listings (both stores searched?), help center, review screenshots,
demo videos, live install if performed — what each yielded, its evidence
grade, and why. If the product is enterprise-gated on mobile too, say
which ladder rungs produced whatever mobile truth exists; if the only
evidence is the store listing, say that — it bounds how much the section
can claim.

## Exit criteria

You can say, with sources: which app stores the product is on (or isn't),
its release artifacts per store (version, size, last updated, version
history, publisher), what mobile-specific capabilities it has, how mobile
relates to web in feature parity, and what its journeys look like — each
with its evidence basis labeled.
```

## File: saas-platform-teardown/references/04-desktop-platform-audit.md
size: 5883
sha: e0fe62f3b1b58a68f334164b29d0a7b5f3925bf6
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/04-desktop-platform-audit.md

```text
# Phase 3 — Desktop Platform Audit

Goal: establish whether a native desktop app exists, what kind it is, and
what it adds over the browser; capture its release artifacts per
OS/architecture with version history; and walk (or reconstruct) its
journeys, install and first-run especially.

## Steps

1. **Look for a download page** from the recon dossier. If none was found in
   navigation/footer, search explicitly: `"<product name>" download` /
   `"<product name>" desktop app mac windows`. A SaaS with no desktop client
   at all is a normal, reportable outcome — don't force a finding.

2. **If a download exists, identify what kind of app it is** without
   necessarily installing it (installing is optional and environment
   permitting only):
   - File extension/type from the download link (`.dmg`/`.pkg` = macOS,
     `.exe`/`.msi` = Windows, `.AppImage`/`.deb`/`.rpm` = Linux)
   - Check for Electron/Tauri/native-toolkit signals: many
     Electron/electron-builder apps expose an auto-update manifest such as
     `<update-host>/latest.yml` or `/latest-mac.yml` — fetching one (if
     discoverable) confirms Electron and gives a live version number for
     free. Absence doesn't rule Electron out; treat this as one signal
     among several, not proof either way.
   - If the product or its shell is open-source, use `gh` to check the repo:
     `package.json` dependencies (`electron`, `tauri`, `react-native-*`),
     release assets per OS, and release-note history for a desktop feature
     timeline.

3. **Release artifacts — build the per-OS/architecture table.** For every
   OS/architecture combination the vendor offers, capture: exact direct
   download URL, current version, file size, release date, and the
   release-notes/changelog URL:
   - Windows: x64 and arm64 `.exe`/`.msi` as separate rows if both exist
   - macOS: Intel vs Apple Silicon `.dmg` (or a universal binary — say
     which), plus `.pkg` when offered
   - Linux: `.deb` / `.rpm` / AppImage / Flatpak / Snap — each its own row

   File size comes from the download page or a `curl -sI` HEAD request
   (`Content-Length`) against the direct link — no download needed. A
   missing architecture (no arm64 Windows build, no Linux at all) is a
   finding about engineering investment, not a hole in the table.

   **Version history, not just the latest version.** If installers are
   versioned or an update feed is public, mine it for a dated mini timeline
   of the last 5–10 releases: electron-builder's `latest.yml` /
   `latest-mac.yml` (current version, often with history), GitHub Releases
   tags and dates (`gh release list` if the repo is public), a Sparkle
   `appcast.xml` on macOS, or dated entries on the vendor's changelog page.
   Release cadence is itself a finding — it shows whether desktop is
   actively invested or coasting. If a feed 403s or requires auth, note
   that and move on; don't work around it.

4. **Compare desktop vs web feature-for-feature** where you can access
   both: does the desktop app expose everything the web app does, a subset,
   or anything extra? Cross-reference Phase 1's navigation map.

5. **Capabilities beyond the browser** — the reason a desktop app exists or
   doesn't. Check for each (from docs, changelog, help center, screenshots,
   or a live install):
   menu bar/system tray presence, global keyboard shortcuts, offline mode,
   local filesystem access, native notifications, multi-window support,
   auto-launch on login. These are the capabilities a browser tab
   structurally can't offer, so their presence or absence is the real
   signal of *why* a desktop app exists versus being a thin wrapper.

6. **Walk desktop journeys** — install is optional, but if you do install
   (free tier only, same access rules as Phase 1), walk:
   - **Install → first-run:** what launches — a window, a tray icon, a
     menu-bar app? What's the empty state?
   - **Login / account pairing:** watch for the browser-OAuth roundtrip —
     desktop apps commonly open the system browser and hand back via deep
     link. That roundtrip IS the web↔desktop auth integration; record it
     exactly (Phase 4 consumes it). A device-pairing code instead of OAuth
     is a different architecture — record that too.
   - **The core task via a desktop-exclusive capability:** global-hotkey
     capture, tray quick-action, offline usage.
   - Auto-launch and offline behavior.
   If not installing, reconstruct the same journeys from docs, changelog
   entries, help-center articles, and demo video (ladder rungs 1–3) — same
   schema as web journeys (entry point, steps, decision points, handoffs,
   friction, evidence basis, persona tag).

7. **If the "desktop app" is just the website in a wrapper** (no
   capabilities beyond what Phase 1 already found), say so explicitly. That
   is a legitimate and common finding, not a failure to dig deeper — and it
   feeds Phase 4's business-objective map (the "why" was distribution, not
   capability).

## Access-methods log (required output of this phase)

Fill the desktop access log (template `04-desktop-platform.md`): installed
and walked live / release feed only (`latest.yml`, GitHub Releases) /
docs + changelog / help center / demo video / review screenshots — what
each yielded, its evidence grade, and why. Update-feed data counts as
vendor-documentary grade. If you never verified the installer beyond its
URL, the log must say so — an un-fetched download link is `Reported`, not
`Confirmed`.

## Exit criteria

You can say: does a native desktop client exist, for which OSes and
architectures (with the artifact table: URL, version, size, date, release
notes), what its release cadence shows, what framework signals point to,
what it can do that the browser tab can't, and how its journeys behave —
with the access log saying how you know.
```

## File: saas-platform-teardown/references/05-integration-architecture.md
size: 7275
sha: f1355564303f74bd17874cbd4aea7edf6cbc756b
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/05-integration-architecture.md

```text
# Phase 4 — Integration Architecture

Goal: synthesize how web, mobile, and desktop relate to each other — and
WHY the product is wired that way. Technical topology alone ("shared auth,
same API domain") doesn't support decisions; every integration point also
needs the business objective a PM would give for building it that way.
This phase is synthesis over evidence gathered in Phases 0–3, plus a few
targeted lookups. Do not re-audit platforms; connect what's already known.

## Technical questions to resolve, each with evidence

1. **Shared account/auth?** Same login credentials and session model across
   platforms is the baseline expectation — confirm it (or find the
   exception, e.g. desktop requires a separate device-pairing code).

2. **Same backend?** Compare the API domain observed from the web app's
   network traffic (Phase 1) against any API domain referenced in mobile app
   store metadata, desktop update manifests, or public API docs. Matching
   domains across platforms is strong evidence of one shared backend;
   different domains suggest separate services or a BFF (backend-for-frontend)
   layer per platform.

3. **Sync model.** Real-time (websocket/push-based), periodic poll, or
   manual export/import? Status-page incident history (from Phase 0) often
   mentions "sync service" or "realtime service" outages — that's a direct,
   citable signal of the actual architecture, not marketing language.

4. **Push notification path.** If the mobile app requests notification
   permissions, that implies APNs (iOS) / FCM (Android) integration, which
   in turn implies a backend notification service that both mobile clients
   and (often) the web app's in-app notification center draw from. Note this
   as `Inferred` unless directly confirmed in docs.

5. **Public API / integrations surface.** Does a public API or webhook
   system exist? Is the product listed in Zapier/Make/n8n's app directories
   (search for this)? A product with a mature public API and an
   integrations marketplace has a materially different architecture posture
   (multi-tenant platform) than one without.

6. **What's the single source of truth?** For products where one platform is
   clearly primary (usually web) and others are companions, say so plainly
   — this is often the most useful sentence in the whole report for someone
   deciding whether they need the mobile app at all.

## The "why" layer: business-objective mapping

For every integration point the questions above surface — shared auth, sync
model, notification paths, each platform's existence and its exclusive
features, every journey handoff — pair the technical finding with the
business objective it serves. A manager deciding whether this product is a
threat reads the "why" column, not the topology. Two paths, in order:

1. **Stated rationale → `Confirmed`.** Vendors explain platform strategy
   more often than you'd expect. Mine, in this order:
   - Changelog entries ("now on iOS so you can approve requests from
     anywhere") — dated, specific, citable
   - App Store / Play listing descriptions ("capture receipts the moment
     you get them") — the mobile value prop in the vendor's own words
   - Engineering blog posts and launch posts (Product Hunt maker comments
     often state why a platform was built)
   - Help-center framing ("manage billing on the web, track expenses on
     mobile")
   - The marketing site's per-platform pitch pages
   - Job postings (a burst of mobile or desktop hiring is strategy in
     plain sight — `Inferred` even though the posting is real, because the
     strategy conclusion is yours)
   Cite the exact source next to the objective.

2. **Explicit inference → `Inferred`, with the reasoning shown.** When
   nothing is stated, infer against this pattern library, then TIE THE
   PATTERN TO THIS PRODUCT'S OBSERVED BEHAVIOR — a pattern with no observed
   evidence is a guess, not an inference:
   - **Companion mobile app →** capture at the moment of stimulus
     (photo/scan/voice), act or approve away from the desk, recover
     abandoned flows started on web. Evidence to look for: mobile-exclusive
     camera/scan/offline capabilities, push permissions, review complaints
     about what's missing (the missing part tells you what the app is FOR).
   - **Desktop app →** cut time-to-capture on the core loop (tray, global
     hotkeys), offline/latency tolerance, system-level integration
     (filesystem, native notifications). Evidence: which capabilities from
     Phase 3's beyond-the-browser table are actually present — a
     wrapper-only app means the "why" was distribution/brand presence, not
     capability.
   - **Web as source of truth →** administration, bulk work, billing,
     configuration. Evidence: journey handoffs that push users TO web for
     admin/billing even from native apps.
   - **Mobile-only hardware pairing →** field/workforce workflows.
     Evidence: pairing documentation living only in mobile help sections
     (cross-check `references/08-hardware-integrations.md` if hardware was
     found).

   Write the reasoning chain, not just the conclusion — the template's
   format is: "menu-bar app + global hotkey + no offline mode (Phase 3
   table) → the desktop app exists to cut time-to-capture on the core
   workflow, consistent with this category's retention being capture-
   latency-driven — `Inferred`."

Every row of the business-objective map (template
`07-integration-architecture.md`) is: integration point | technical
evidence | business objective | tag — `Confirmed` (vendor-stated, cited) or
`Inferred` (reasoning shown).

## Journey handoff & persona synthesis

Consolidate the per-platform journey findings from Phases 1–3 (each
playbook recorded handoffs and personas for exactly this moment):

- **Handoff map.** Every point where a journey crosses platforms — web→
  mobile deep links, QR "scan to install", mobile→web escape hatches for
  admin/billing, desktop login roundtrips through the browser. For each:
  is the handoff supported (deep link / QR / manual re-login), and where
  does it break? A broken handoff is a friction finding with a journey-
  level citation, which is worth more than any amount of "seamless sync"
  marketing copy.
- **Persona × platform matrix.** Which personas the product serves (from
  roles/permissions observed in team setup and from journey variants), and
  which platform primarily serves each — e.g. admin lives on web, end user
  lives on mobile, power user lives on desktop. This matrix is often the
  sharpest one-glance answer to "who is this product really for?"

## Output for this phase

The architecture narrative (not a literal system diagram unless you have
strong direct evidence for one), the platform × {auth model, data source,
sync behavior, notification path} table with each cell tagged Confirmed /
Reported / Inferred — PLUS the business-objective map, the journey handoff
map, and the persona × platform matrix. All of it lands in template
`07-integration-architecture.md`, with the handoff map and persona matrix
mirrored in `05-user-journeys.md`. If Phase 0 found hardware, the hardware
playbook's business-rationale findings join this map.
```

## File: saas-platform-teardown/references/06-research-sweeps.md
size: 13662
sha: 9ab1abd39988566cdd9f6051217ba15d9a3bf381
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/06-research-sweeps.md

````text
# Phase 5 — Broad Research Sweeps

Fifteen ready-made sweeps answer the broad, fast-moving questions every
teardown needs — company facts, store listings, desktop distribution,
integration directories, pricing pages, revenue signals. They are
engine-agnostic: the same question, the same sourcing rules, the same
output discipline regardless of which engine runs them. Sweeps are not a
substitute for live DOM access in Phase 1; use them for facts that live in
text on the open web, not for live in-app behavior.

## Picking the engine (once, at Phase-5 dispatch)

Run `command -v agy` (bash) exactly once, when Phase 0 has produced the
concrete questions — unless the run's scope already excludes `agy`, in
which case skip the check and record the exclusion:

- **Absent → Engine A (built-in web search/fetch). This is the default
  path and the normal case — not a degraded mode.** Do not warn, do not
  block, do not ask the user. Run the sweeps sequentially inside your own
  tool loop.
- **Present → Engine B (`agy`, optional power path).** Same sweeps, fanned
  out as parallel headless shell jobs — freeing Claude Code's own
  web-search budget for the judgment-heavy synthesis work. Read the
  Engine B section (especially the permissions trap) before the first
  sweep.

Either way, record which engine ran the sweeps in the report's methodology
section.

**Honesty rule: pace differs by engine; quality must not.** An Engine A
report must not be visibly thinner on sourced claims than an Engine B one
would have been — Engine A costs more of your context, not less of the
reader's confidence.

## The 15 sweeps (engine-agnostic)

Fire once Phase 0 has a product name/domain. Work in priority order — the
first five unblock later phases, so they run first under either engine.
Sweep 13 is conditional by design: when Phase 0 found no hardware,
recording it as skipped-conditional in the sweep ledger is the correct
outcome, not a gap.

1. **Company facts** — "Find <product>'s parent company, founding year,
   funding stage/amount if public, and approximate headcount. Cite each
   fact to a specific source (Crunchbase, LinkedIn, official blog, press)."

2. **App store presence** — "Find the official iOS App Store and Google Play
   listing URLs for <product> (not a similarly-named unrelated app — verify
   by matching the developer/publisher name to <company>). Report each
   store's last-updated date and current version number."

3. **Desktop distribution** — "Find whether <product> ships a native
   desktop application for macOS, Windows, and/or Linux, and the direct
   download URL(s). If none exists, say so explicitly."

4. **Integrations directory** — "List <product>'s official integrations or
   app marketplace, and separately check whether <product> has a listing in
   Zapier's, Make's, and n8n's app directories. Report counts and a few
   named examples per source, with URLs."

5. **Public API** — "Does <product> have public developer/API documentation?
   Report the docs URL, authentication method described (API key/OAuth),
   and whether webhooks are supported."

6. **Pricing tiers** — "List <product>'s current pricing tiers, prices, and
   the 3–5 headline features that differ between tiers, from the official
   pricing page."

7. **Tech-stack corroboration** — "Search job postings and engineering blog
   posts from <company> for their web/mobile/desktop tech stack (framework
   names, languages, infra providers). Cite each claim to a specific
   posting or post."

8. **Revenue / business-scale estimates** — "Find revenue or ARR estimates
   for <company> from Owler, Craft.co, Growjo, and any PitchBook or press
   coverage of funding rounds. Report each funding round (amount, date,
   stage, lead investor) and LinkedIn's 'estimated revenue' band if
   visible. Return each estimate SEPARATELY with the source site named —
   do not average or merge them. Say 'not found' per source if absent."

9. **Mobile app traction** — "Find any public download or revenue estimates
   for <product>'s iOS and Android apps from Sensor Tower, data.ai
   (Similarweb), or Appfigures — usually via blog posts or press articles
   citing them. Report the figure, which app, the estimating firm, and the
   citing page URL."

10. **Web traffic proxy** — "Find Similarweb or SEMrush public estimates of
    monthly visits and global rank for <domain>. These are traffic
    proxies only — label them as scale indicators, not revenue."

11. **Public-filings check** — "Is <company> publicly traded, a subsidiary
    of a public company, or otherwise a regulator filer (SEC 10-K/20-F,
    Form 990)? If yes, name the filing and the revenue the latest filing
    states for the most recent fiscal year."

12. **Customer-count claims** — "Find public customer/team/logo counts for
    <product>: marketing-site claims ('trusted by N teams'), case studies,
    press releases, about pages. Report the number, the claim's exact
    wording, and the page it appears on."

13. **Hardware filings (only when Phase 0 found hardware)** — "Search the
    FCC ID database and fccid.io for wireless equipment authorization
    filings by <company> or branded '<product>' devices. Report FCC IDs,
    the grantee/manufacturer name on each filing, and the device type.
    Also check for iFixit or other teardown coverage of the hardware."

14. **Changelog / release-notes history** — "Find <product>'s changelog or
    release-notes page. Summarize the last 5–10 dated entries: version or
    date, platform affected (web/iOS/Android/desktop), and headline
    changes."

15. **Wayback availability** — "Check the Wayback Machine for snapshots of
    <url>: report the earliest capture date, the most recent capture date,
    and roughly how many captures exist."

Two integrity rules for the revenue sweeps specifically: never merge
estimates from different sources into one number (each figure keeps its
source; the report's revenue table does the comparison), and treat a
funding round as a fact with a revenue *multiple* attached to it — the
multiple is an assumption, so the output is a stage signal, not a figure.

Adjust wording per product, but keep the role/question/sourcing/output-shape
structure — that's what makes the answers usable without a second pass of
cleanup.

### Shared prompt skeleton (both engines)

Every research prompt specifies role, exact question, required sourcing,
and required output shape — vague prompts get vague, ungrounded answers
back. Template:

```
You are a product research analyst. Search the current web (today's date
matters — this product may have changed recently) and answer ONLY the
question below using information you can attribute to a real, named source.
If you cannot verify something, say "not found" rather than guessing.

QUESTION: <specific question>

Return ONLY valid JSON, no prose, no markdown fences, matching this shape:
{ "answer": "...", "sources": ["https://...", "..."], "confidence": "confirmed|reported|unverified" }
```

Output discipline, either engine: every fact a sweep yields is recorded as
{claim, source URL, confidence} and appended to the recon dossier as you
go — Phase 6 assembly merges notes, it does not re-search.

## Engine A — built-in web search/fetch (default, zero-install)

The built-in WebSearch/WebFetch tools run the same sweeps, sequentially.
The failure mode to design against is thin fan-out — many shallow queries
and few pinned sources. Instead:

- **Prioritize; don't fan out.** Company facts, app-store presence,
  desktop distribution, pricing, and revenue first — Phases 1–4 and the
  report's pricing/revenue files block on those. Changelog, traffic
  proxies, Wayback, and the rest run afterwards, or are consciously
  skipped and logged as skipped when the product makes them moot (no
  changelog page, no desktop app to check Wayback for, and so on).
- **1–3 well-formed queries per sweep.** Compose the query from the sweep
  text itself — product name, site restriction, estimator name — rather
  than firing many fragments. One query that names its sources beats five
  that don't.
- **WebFetch the source once you've found it.** A fetched primary page
  (the official pricing page, the store listing itself, the integrations
  directory) beats three search summaries of it — and the fetch upgrades
  the claim: you saw the page, not a description of the page.
- **Append per-fact lines to the recon dossier as you go** (claim, source
  URL, confidence) rather than holding facts in working memory for the
  whole run.
- **Wayback exception (sweep 15):** some fetchers refuse
  `web.archive.org` itself. The availability API —
  `https://archive.org/wayback/available?url=<url>` — answers through
  the unblocked host and yields a current snapshot URL; if the fetcher
  refuses raw snapshot URLs too, record what the API gives and flag
  earliest-capture date as unobtainable under this engine rather than
  guessing.
- **Client-rendered pages read as empty.** JS-rendered sites — Swagger/
  OpenAPI UIs, Play Store listings, some docs portals — return shell
  markup with no content to a static fetch. Don't report the sweep as
  failed; name a static-readable fallback (third-party client docs,
  status-page component lists, GitHub SDK repos, platform APIs like
  iTunes Lookup) and mark what that downgrades.

## Engine B — `agy` (optional power path)

`agy` (Antigravity CLI) is Gemini-backed with grounded web search, and it's
scriptable headlessly. It is a power path, not a requirement — every sweep
above runs fine on Engine A; Engine B runs them in parallel and offloads
the raw search/browse tokens.

### Invocation (verified working as of agy 1.1.27, September 2026)

```bash
mkdir -p .agy-out && agy -p "PROMPT" --output-format stream-json \
  --model gemini-3.8-flash --effort medium \
  > .agy-out/<slug>.jsonl
```

Flag notes, so future drift is easy to diagnose:

- `-p` (print mode) is already non-interactive — there is NO
  `--non-interactive` flag; passing one aborts the run with
  `flags provided but not defined`.
- **Model-string aging rule:** the `--model` value is the perishable part
  of this block. The durable invariant is that `--model` REQUIRES a paired
  effort — either `--effort medium` or `--effort=medium` (both accepted);
  omitting it fails with `invalid model selection`. `medium` is the right
  default for research sweeps; drop to `low` for trivial lookups. When a
  future agy version 404s the pinned name, run `agy models` and pick the
  current flash-family entry.
- Long research prompts can exceed the default 5-minute wait; add
  `--print-timeout 10m` if a sweep is timing out.

### Permissions: the headless killer (read this before debugging "empty" answers)

Research prompts make agy call its own tools (`search_web`, `read_url`, …),
and in headless mode there is no one to approve them. A blocked run looks
like this — note the trap that status still says `SUCCESS`:

- stderr: `jetski: no output produced — a tool required the "read_url"
  permission that headless mode cannot prompt for, so it was auto-denied.`
- result event: `"status":"SUCCESS"` with `"response":""` (EMPTY)

So ALWAYS check the response is non-empty, not just the status. Two fixes,
in order of preference:

1. **Allow-rules (surgical).** `~/.gemini/antigravity-cli/settings.json` →
   `permissions.allow` contains `"search_web"`, `"read_url(*)"`,
   `"read_url_content(*)"`, `"read_resource(*)"`. GOTCHA: the permission
   name is `read_url`, which differs from the tool name `read_url_content`
   — the error message quotes the name to use. With these rules the plain
   invocation above just works.
2. **`--dangerously-skip-permissions` (any machine, blanket).** Auto-approves
   ALL agy tool use, including terminal execution — only use it when the
   allow-rules are missing and never feed untrusted page content into agy
   prompts, since injected instructions could drive those tools.

A third signature, prompt-shaped rather than permission-shaped: if stderr
quotes the `command` permission, the sweep tried to verify a URL by
shelling out (curl/HEAD) and was auto-denied — the retry is
deterministically empty. Sweeps should report URLs *as listed on the
page*, not probe them; verification by HEAD request belongs to the
platform-audit phases. Telling the model not to probe helps but is not
reliable (verified 2026-09: the desktop-distribution sweep kept reaching
for the shell even when told not to). The two dependable escapes: a
narrow `command` allow-rule (grants agy terminal execution — scope it
deliberately), or the documented per-sweep fallback below — rerun that
one question on the built-in search tools.

Run several sweeps as background bash jobs in parallel (`&` + `wait`, or
separate tool calls) rather than one at a time — this is the whole point
of shelling out to a second agent.

Parse the result with `jq`. The stream is NDJSON with three event types:
`init`, `step_update` (progress noise), and one final `result`. The answer
is `.result.response`, and `.result.status` is `SUCCESS` or `ERROR`:

```bash
# the answer text
jq -r 'select(.event=="result") | .result.response' .agy-out/<slug>.jsonl
# status check — and verify NON-EMPTY response (see permissions trap above)
jq -r 'select(.event=="result") | "\(.result.status) len=\(.result.response | length)"' \
  .agy-out/<slug>.jsonl
```

If a sweep fails or returns empty, retry once, then fall back to the
built-in web search/fetch tools for that question rather than stalling the
pipeline.
````

## File: saas-platform-teardown/references/07-report-assembly.md
size: 4988
sha: a5ec235995d5fad6af31ebd489c48595c74da8a1
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/07-report-assembly.md

````text
# Phase 6 — Report Assembly

## File-count decision

- **Single file** (`<product-slug>-teardown.md`) when the product is small
  enough that web+mobile+desktop+integration findings fit comfortably in one
  document a person would actually read top to bottom — roughly, when there's
  no native desktop app AND mobile is a thin companion AND there's no
  hardware. Use the template files' order below as section headers instead of
  separate files.
- **Multi-file** (a `<product-slug>-teardown/` folder using every file in
  `assets/report-template/`) when there's meaningful depth on 3+ platforms,
  hardware coverage, or reference-style consumption — likely to be read
  section-by-section rather than once end to end.

Default to multi-file for anything that made it through all four platform
phases with real findings — it's the more useful artifact and costs nothing
extra to produce once the research is done.

## Template files, in reading order

| File | Carries |
|---|---|
| `00-INDEX.md` | Executive summary, at-a-glance table, access-methods summary, links |
| `01-overview-and-recon.md` | Company, positioning, **complete verified link inventory**, hardware check, business-scale signals |
| `02-web-platform.md` | Access log, navigation, web journeys, features, API domains |
| `03-mobile-platform.md` | Access log, store release artifacts, version history, mobile journeys, parity |
| `04-desktop-platform.md` | Access log, per-OS/arch artifact table, version history, desktop journeys |
| `05-user-journeys.md` | All platforms × the five journey types, personas, handoff map, persona × platform matrix |
| `06-hardware-integrations.md` | Device families (protocol, pairing matrix, firmware, manufacturer) — or the explicit none-finding |
| `07-integration-architecture.md` | Cross-platform summary, **business-objective map**, narrative, API ecosystem |
| `08-pricing-revenue-sources.md` | Pricing tiers, **revenue estimates with method per figure**, source list |

`05` and `06` are never skipped: journeys are the report's decision-grade
core, and hardware gets an explicit "none found (checked where)" even when
empty. An absent section is a missing answer, not a negative finding.

## Assembly steps

1. Copy `assets/report-template/*.md` into the output location and fill each
   placeholder — do not leave template scaffolding text in the final output.
2. Every section file opens with:

   ```
   > Researched: <date>. Sources current as of this date; SaaS products
   > change frequently — verify anything decision-critical before acting on it.
   ```

3. Every factual bullet ends with a confidence tag and, where applicable, a
   link: `— Confirmed (screenshot, in-app)`, `— Reported ([G2 review](url))`,
   `— Inferred (shared session cookie domain across web and desktop)`.
4. **Access-log check:** every platform file (02/03/04) states which access
   methods produced its claims and their evidence grades, and `00-INDEX.md`
   summarizes them at a glance. A reader must be able to tell verified truth
   from secondhand reconstruction without re-deriving it. If a platform
   section has no access log, it is not done.
5. **Revenue method check:** every revenue/scale figure in 08 names its
   method and source; estimates are labeled estimates; the bottom-up range
   shows its math and assumptions; any regulator-filed figure is marked as
   filed, not estimated. A lone unsourced number is worse than no number —
   source it or cut it.
6. **Journey check:** every journey in 05 carries an evidence basis (walked
   live / reconstructed from which ladder rung), persona tags where the
   product serves multiple user types, and observed-or-reported friction.
   "Reconstructed" must never read as "walked."
7. `00-INDEX.md` is a one-screen executive summary plus links to every other
   file — write this LAST, once you know what the report actually contains.
8. `08-pricing-revenue-sources.md` ends with a flat list of every source URL
   used anywhere in the report, deduplicated — this is the report's
   bibliography and lets a reader audit any claim.

## Writing style for the report body

- Plain, declarative sentences. This is documentation, not marketing copy —
  avoid adjectives the product's own landing page would use ("powerful",
  "seamless", "effortless") unless directly quoting and attributing them as
  the company's own claim.
- Paraphrase all secondary-source content; never reproduce review text,
  article paragraphs, or store descriptions verbatim beyond a very short
  attributed phrase.
- Tables over prose wherever the content is naturally tabular (feature ×
  platform, plan × price, platform × sync behavior) — this is a reference
  document, not an essay.

## Final step

Write all files under `./<product-slug>-teardown/` in the current working
directory (or a single file at that path) and present them to the user. A
report that's written but never surfaced is not a completed teardown.
````

## File: saas-platform-teardown/references/08-hardware-integrations.md
size: 5433
sha: 4b59b29a9fcb24ec7a30bb552aec848a04ee14f5
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/references/08-hardware-integrations.md

```text
# Conditional — Hardware Integrations

Load this playbook ONLY when Phase 0's hardware check (or a later phase —
e.g. Phase 2 finding Bluetooth/NFC/USB permissions in a store listing)
found a physical-device touchpoint. If the check found none, this file
stays unread and the report carries the explicit finding instead: "No
hardware integration found (checked: marketing nav/footer/copy, pricing
SKUs, docs nav, jobs page; store permissions showed no Bluetooth/NFC/
USB)." Zero cost for hardware-less products is the design goal.

Goal: document every way the product touches physical hardware —
connection protocols, pairing flows, which platforms can pair (a common
blind spot: pairing is mobile-only), firmware/SDK update paths,
certified-hardware programs, and who actually manufactures the hardware —
plus the business rationale for hardware existing at all.

## Steps

1. **Enumerate the touchpoints.** Sources: marketing product pages for
   devices, hardware SKUs or bundles on the pricing page, docs-nav
   hardware/setup sections, store-listing permissions (BLE, Bluetooth
   Classic, NFC, USB accessory), the integrations marketplace's hardware
   category if one exists, and jobs-page embedded/firmware roles. Name
   each touchpoint as a device family ("card reader", "barcode scanner",
   "temperature sensor", "receipt printer") — the report is organized per
   family.

2. **Per device family, document each of these — every one is a template
   row, so a gap in the row is itself a finding:**
   - **Connection protocol** — BLE, Bluetooth Classic, USB, NFC, Wi-Fi
     direct, Ethernet, proprietary dongle. Help-center setup articles
     almost always state this explicitly; store permissions corroborate
     (Android `BLUETOOTH_SCAN`/`BLUETOOTH_CONNECT`, iOS
     `NSBluetoothAlwaysUsageDescription`, NFC reader session entitlements).
   - **Setup / pairing flow** — which screen initiates pairing, QR-code vs
     button-hold vs serial-number entry, whether the device binds to an
     account or a workspace. Reconstruct from help-center articles and
     demo videos per the ladder (`references/02-web-platform-audit.md`) —
     same rungs, same evidence grades.
   - **Platform pairing matrix — the common gap.** Which of web / desktop
     / iOS / Android can pair with AND use the device. Pairing is
     frequently mobile-only: BLE from desktop is uncommon, and Web
     Bluetooth is Chromium-only and often absent — check before assuming.
     Record the matrix and flag every empty cell; "mobile-only pairing
     while web is the admin surface" is a deliberate scope decision, i.e.
     business logic for Phase 4's objective map.
   - **SDK / firmware update mechanism** — OTA via which app? Desktop-side
     updater? Are firmware versions release-noted anywhere? Changelog
     entries mentioning firmware updates, and their cadence, signal how
     alive the hardware line actually is.
   - **Official partner / certified-hardware list** — URL and entry count.
     A certified list implies a partner program (ecosystem moat, maybe a
     revenue line); its absence means either first-party hardware or
     generic "works with any X" support — distinguish which.

3. **Identify the actual manufacturer.** Branded hardware is usually
   contract-manufactured, and the public filing trail says by whom:
   - **FCC ID lookup (public record).** The FCC ID sits on the device
     label — product photos usually show it — and fccid.io / the FCC's
     equipment-authorization database expose the *grantee*, whose name is
     often the real OEM rather than the brand on the box. Radio-module
     approvals in the same filing reveal the chipset family.
   - **Other certification trails:** CE / UL listings, Bluetooth SIG
     QDID/PID listings (they name the stack vendor), Wi-Fi Alliance
     certification.
   - **Teardown coverage** — iFixit and similar, where it exists.
   - **Import records (optional signal)** — public US customs manifest
     databases (e.g. ImportYeti) name the shipping manufacturer.
   Tag each identification `Reported` (the filing/grantee is named) or
   `Inferred` ("grantee matches a known POS OEM — likely contract
   manufacture"), never stronger than the evidence.

4. **Business rationale per device family** — feeds Phase 4's
   business-objective map. Does the hardware exist to (a) unlock a
   workflow impossible in pure software (payments, physical capture,
   sensing), (b) create lock-in / switching costs, (c) add a hardware
   revenue line (check the pricing page's SKUs and their pricing), or
   (d) raise data quality or capture latency? Cite the vendor's stated
   rationale where one exists; otherwise infer with the reasoning shown,
   under the same rules as Phase 4's "why" layer.

## Constraints

Filing databases and certified-hardware lists are public record — use them
freely. Do not purchase hardware, dump or reverse-engineer firmware, or
attempt any DRM/protection bypass. This playbook never requires an account
or a device in hand; it runs entirely on public documentation, filings,
and imagery.

## Exit criteria

Every device family has: protocol, pairing flow, platform pairing matrix
(with gaps flagged), firmware/update path, certified-list status,
manufacturer evidence, and a business-rationale line — OR the report
carries the explicit no-hardware finding listing every location checked.
```

## File: saas-platform-teardown/assets/report-template/00-INDEX.md
size: 2392
sha: ca031510df3ce455baac3bce21b1fe81bd059174
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/00-INDEX.md

```text
# <Product Name> — Platform Teardown

> Researched: <date>. Sources current as of this date; SaaS products change
> frequently — verify anything decision-critical before acting on it.
>
> *(Write this file LAST — it is the executive summary of everything the
> other section files establish, including the access-methods table.)*

## What this is

One paragraph: what the product does, who it's for, and its category peers.

## At a glance

| | |
|---|---|
| Company | |
| Founded / funding | |
| Web app | Yes — <url> |
| Native mobile app | Yes / No / Companion only — <store links> |
| Native desktop app | Yes / No — <download links> |
| Hardware integration | None found (checked: <where>) / Yes — <device families> |
| Public API | Yes / No — <docs url> |
| Pricing | <lowest paid tier> – <highest tier> |
| Estimated business scale | <range> — <method> (details in 08) |
| Primary platform | Which platform is the real source of truth, per 07 |

## How this was researched (access methods at a glance)

| Platform | Access method(s) used | Evidence grade | Why |
|---|---|---|---|
| Web | e.g. free-trial signup (disposable identity) | live | self-serve trial existed |
| Mobile | e.g. store listings + help center | vendor-documentary / third-party | no device available; product self-serve on mobile |
| Desktop | e.g. installed and walked (free tier) | live | installer public |

This table is the report's honesty layer: it says how much of what follows
is verified truth versus secondhand reconstruction. Detail per platform
lives in each platform file's "Access methods used" section.

## Contents

- [01 — Overview & Recon](01-overview-and-recon.md)
- [02 — Web Platform](02-web-platform.md)
- [03 — Mobile Platform](03-mobile-platform.md)
- [04 — Desktop Platform](04-desktop-platform.md)
- [05 — User Journeys](05-user-journeys.md)
- [06 — Hardware Integrations](06-hardware-integrations.md)
- [07 — Integration Architecture](07-integration-architecture.md)
- [08 — Pricing, Revenue & Sources](08-pricing-revenue-sources.md)

## Biggest takeaways

3–5 bullets: the things a reader most needs to know, including any notable
gap between marketing claims and observed reality.

## Confidence & gaps

What could not be verified, and why (paywall, no public API, no reviewer
access, etc.) — be explicit rather than silent about limitations.
```

## File: saas-platform-teardown/assets/report-template/01-overview-and-recon.md
size: 2147
sha: 6d2af6a26a976f728afc5ba7463f0d73f96cb3c7
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/01-overview-and-recon.md

```text
# 01 — Overview & Recon

> Researched: <date>

## Company

- Name, ownership, founding year, funding — each fact tagged Confirmed/Reported/Inferred with a source.

## Product positioning

- What problem it claims to solve, who it's built for, main competitors.

## Complete link inventory (web release artifacts)

The web platform "ships" URLs — this inventory is its release artifact.
Every URL below was verified by fetching it (a footer link that 404s is
itself a finding, recorded in Notes).

| Surface | Exact URL | Notes (verified / 404 / requires login) |
|---|---|---|
| Marketing site | | |
| Web app / login | | |
| Signup | | |
| Pricing | | |
| Docs | | |
| API reference | | |
| Status page | | |
| Blog | | |
| Changelog / release notes | | |
| Community / forum | | |
| Public GitHub org / repos | | |

## Hardware touchpoint check

Explicit either way — absence is a finding, not a missing section:

- Either: **No hardware integration found** — checked: marketing
  nav/footer/copy, pricing-page SKUs, docs nav, jobs page, mobile store
  permissions (no Bluetooth/NFC/USB).
- Or: device families found — list them here with a one-liner each, full
  coverage in 06.

## Business-scale signals (summary)

One line per signal, each with source and tag; full estimates, methods, and
the bottom-up range are in 08.

| Signal | Value | Source | Tag |
|---|---|---|---|
| e.g. Funding | $X Series B, <date> | press coverage | Reported |
| e.g. Revenue estimate | $X–Y | Owler | Reported (algorithmic) |
| e.g. Monthly web visits | N | Similarweb | Reported (scale indicator, not revenue) |
| e.g. Customer count claim | "N teams" | marketing homepage | Reported |

## Platform surfaces found

| Surface | URL | Notes |
|---|---|---|
| Marketing site | | |
| Web app | | |
| iOS app | | |
| Android app | | |
| Desktop (macOS) | | |
| Desktop (Windows) | | |
| Desktop (Linux) | | |
| API docs | | |
| Status page | | |
| Public repos | | |

## Tech stack signals (marketing site vs. app)

| Layer | Marketing site | App |
|---|---|---|
| Frontend framework | | |
| Hosting/CDN | | |
| Analytics | | |
| Notable other | | |
```

## File: saas-platform-teardown/assets/report-template/02-web-platform.md
size: 1493
sha: befb6ed8a6881b9beb6a410966195c62609d8451
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/02-web-platform.md

```text
# 02 — Web Platform

> Researched: <date>

## Access methods used

Which methods actually produced this section's claims, what each yielded,
its evidence grade, and why it was chosen. This is how a reader weighs the
rest of the section.

| Method | What it yielded | Evidence grade | Why used |
|---|---|---|---|
| e.g. Free-trial signup (disposable identity) | live walk of all five journeys | live | self-serve trial existed |
| e.g. Help-center articles | higher-tier admin screens | vendor-documentary | trial tier couldn't reach them |

## Navigation map

| Section | Purpose | Plan tier required |
|---|---|---|
| | | |

## User journeys (web)

Walked or reconstructed per the playbook; full schema, per-platform
consolidation, personas, and the handoff map are in 05.

| Journey | Persona | Evidence basis | Key friction observed |
|---|---|---|---|
| Onboarding / first-run | | walked live / reconstructed from <rung, source> | |
| Core "aha" task end to end | | | |
| Account & team setup | | | |
| Churn-risk moment (plan limit / cancel flow) | | | |
| Web-exclusive flow | | | |

## Feature inventory

| Feature | Description | Plan tier | Confidence |
|---|---|---|---|
| | | | |

## Responsive behavior

Does the web app itself work as a mobile experience? Observed at ~375px width.

## Observed API domain(s)

List any API/network domains observed, for cross-reference in Phase 4.

## Screenshots

Reference captured screenshots here (file names/paths) with one-line captions.
```

## File: saas-platform-teardown/assets/report-template/03-mobile-platform.md
size: 2469
sha: 6810df3950eecc30509c75c1558e7a0ec6775e24
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/03-mobile-platform.md

```text
# 03 — Mobile Platform

> Researched: <date>

## Access methods used

| Method | What it yielded | Evidence grade | Why used |
|---|---|---|---|
| e.g. Play Store + App Store listings | release artifacts, screenshots, permissions | vendor-documentary | no device/emulator available |
| e.g. Help-center mobile articles | journey reconstruction | vendor-documentary | |

## Existence

| Store | Listing found? | URL | Publisher |
|---|---|---|---|
| iOS App Store | | | |
| Google Play | | | |

If no native app exists: state that explicitly, with the search terms used
to confirm absence, and whether the web app is responsive enough to serve as
the mobile experience (cross-reference 02-web-platform.md).

## Release artifacts (store-listing metadata)

Store-listing metadata is the ceiling for mobile release data — no APK/IPA
extraction is attempted, by design.

| Store | Version | Size | Last updated | Min OS | Age rating |
|---|---|---|---|---|---|
| Google Play | | | | | |
| iOS App Store | | | | | |

Direct APK / sideload distribution: <none found / public link + context
(e.g. enterprise/MDM distribution)>.

## Version history signal (last 5–10 releases)

| Version | Date | Notable change |
|---|---|---|
| | | |

Release cadence read: actively invested / coasting — one sentence with
evidence.

## Permissions requested

| Permission | iOS | Android | Implied capability |
|---|---|---|---|
| | | | |

Any Bluetooth / NFC / USB-accessory permission here means hardware pairing —
cross-reference 06-hardware-integrations.md.

## Mobile-specific capabilities

Features present on mobile that aren't on web (widgets, offline mode,
biometric unlock, camera capture, push notifications, etc.)

## User journeys (mobile)

Reconstructed unless a live install was performed (say which). Full schema,
personas, and the handoff map are in 05.

| Journey | Reconstructed from | Key friction reported |
|---|---|---|
| Onboarding / first-run (incl. push-permission ask) | store screenshots + help center | |
| Core "aha" task | | |
| Platform-exclusive flow (widget / offline / scan / biometric) | | |
| Hand-off to web (admin/billing escape hatch) | | |

## Feature parity classification

Companion / Full parity / Mobile-first extras — with the evidence for the classification.

## Review-derived feature gaps

Bullet list of recurring feature requests/complaints from a representative
sample of recent reviews (not sentiment — feature signal only).
```

## File: saas-platform-teardown/assets/report-template/04-desktop-platform.md
size: 2591
sha: 8d2c678a87358f59e7286dd52ad631d24f6e12e9
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/04-desktop-platform.md

```text
# 04 — Desktop Platform

> Researched: <date>

## Access methods used

| Method | What it yielded | Evidence grade | Why used |
|---|---|---|---|
| e.g. Installed and walked (free tier) | live install + first-run journey | live | |
| e.g. Update feed (`latest.yml`) / GitHub Releases | version history | vendor-documentary | |

## Existence

If no native desktop app exists: state that explicitly. If it's just the
website in a wrapper with no added capability, state that explicitly too —
both are legitimate findings.

## Release artifacts (per OS and architecture)

Every combination the vendor offers, each with its exact direct download
URL, current version, file size (if the server returns no content length
— common on signed-URL redirectors — record "not disclosed", don't
guess), release date, and release-notes link. A
missing architecture (no Windows arm64, no Linux) is a finding about
engineering investment — record it in Notes.

| OS | Arch | Installer type | Direct download URL | Version | Size | Release date | Release notes URL | Notes |
|---|---|---|---|---|---|---|---|---|
| Windows | x64 | | | | | | | |
| Windows | arm64 | | | | | | | |
| macOS | Apple Silicon | | | | | | | |
| macOS | Intel | | | | | | | |
| Linux | x64 | deb/rpm/AppImage | | | | | | |

## Version history (from update feed / changelog — last 5–10)

Mined from a public update feed (electron-builder `latest.yml`, GitHub
Releases, Sparkle `appcast.xml`) or the vendor's changelog page.

| Version | Date | Notable change |
|---|---|---|
| | | |

Release cadence read: actively invested / coasting — one sentence with
evidence.

## Framework signals

Electron/Tauri/native — and what evidence points to it (update manifest,
open-source `package.json`, file sizes, etc.).

## Capabilities beyond the browser

| Capability | Present? | Evidence |
|---|---|---|
| System tray / menu bar | | |
| Global keyboard shortcuts | | |
| Offline mode | | |
| Local filesystem access | | |
| Native notifications | | |
| Multi-window | | |
| Auto-launch on login | | |

## User journeys (desktop)

Full schema, personas, and the handoff map are in 05.

| Journey | Evidence basis | Key friction |
|---|---|---|
| Install → first-run (what launches: window / tray / menu bar) | | |
| Login / account pairing (browser-OAuth roundtrip or device code) | | |
| Core task via desktop-exclusive capability (hotkey / tray / offline) | | |

## Comparison to web

One paragraph: what, concretely, does the desktop app add over the browser
tab — and if the answer is "nothing but a window," say so.
```

## File: saas-platform-teardown/assets/report-template/05-user-journeys.md
size: 2594
sha: da3060ecabc27dc1ef5644eba1dfeddc2f286e6d
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/05-user-journeys.md

```text
# 05 — User Journeys

> Researched: <date>

The decision-grade core of this report: what using this product actually
feels like, per platform — not what the feature list says it can do.

## Evidence-basis legend

Every journey below states how it is known:

- **Walked live** — performed in-app during this research (claims can be
  Confirmed)
- **Vendor-documented** — reconstructed from help center / official demo
  video / docs (Reported, vendor-authored)
- **Third-party reported** — reconstructed from review screenshots, forums,
  Product Hunt (Reported, third-party)
- **Inferred** — deduced from indirect evidence, reasoning shown

## Personas observed

If the product serves distinct user types, define them here first (from
roles/permissions and journey variants), e.g. **Admin** (config, billing),
**End user** (core task), **Viewer**. If it's single-persona, say that —
that is a finding too.

## 1. Onboarding / first-run

### Web

- **Persona:**
- **Entry point:** <exact URL / screen>
- **Steps:** 1. … 2. … 3. …
- **Decision points:**
- **Handoffs to another platform:**
- **Friction:**
- **Evidence:** walked live / reconstructed from <rung + source>

### iOS

*(same fields)*

### Android

*(same fields)*

### Desktop

*(same fields)*

## 2. Core "aha" task end to end

*(same per-platform structure; walk or reconstruct BOTH admin and end-user
variants where they differ, labeled)*

## 3. Account & team setup

*(same per-platform structure)*

## 4. Churn-risk moment

What happens at a plan limit (what gets blocked, what the upgrade nudge
looks like, how hard the sell is) and in the cancellation flow — per
platform where observable.

*(same per-platform structure)*

## 5. Platform-exclusive flows

Web-exclusive (bulk ops / admin / billing), mobile-exclusive (camera /
widget / offline / biometric / hardware pairing), desktop-exclusive (tray /
global hotkey / system integration) — each with why it lives only there
(link to 07's business-objective map).

*(same per-platform structure)*

## Cross-platform handoff map

Every point where a journey crosses platforms — whether the handoff is
supported (deep link / QR / manual re-login) and where it breaks. Broken
handoffs are friction findings with journey-level citations.

| From → To | Trigger | Supported? | Breaks where | Evidence |
|---|---|---|---|---|
| Web → Mobile | | deep link / QR / manual | | |
| Mobile → Web | | | | |
| Desktop ↔ Web (login) | | | | |

## Persona × platform matrix

| Persona | Primary platform | Secondary | Evidence |
|---|---|---|---|
| | | | |
```

## File: saas-platform-teardown/assets/report-template/06-hardware-integrations.md
size: 1539
sha: 0361b5300e36709fe3d955aa7a0a6731b642c9b6
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/06-hardware-integrations.md

```text
# 06 — Hardware Integrations

> Researched: <date>

## Finding

Either, explicitly:

**No hardware integration found.** Checked: marketing nav/footer/copy,
pricing-page SKUs, docs nav, jobs page (embedded/firmware roles), mobile
store permissions (no Bluetooth/NFC/USB).

— the checked locations are listed because an explicit "none" is a finding.

Or, per device family:

## <Device family — e.g. "Card reader">

| Aspect | Finding | Tag |
|---|---|---|
| Connection protocol | BLE / BT Classic / USB / NFC / Wi-Fi direct / proprietary dongle | |
| Setup / pairing flow | <initiating screen, QR vs button-hold vs serial entry, account binding> | |
| Pairs from web | Yes / No / No evidence found | |
| Pairs from desktop | Yes / No / No evidence found | |
| Pairs from iOS | Yes / No / No evidence found | |
| Pairs from Android | Yes / No / No evidence found | |
| SDK / firmware update mechanism | <OTA via which app? versioned? release-noted?> | |
| Certified / partner hardware list | <URL + entry count> or none found | |
| Actual manufacturer | <FCC grantee name, other filings, teardown coverage> | |

**Why this hardware exists (business logic):** unlocks a
software-impossible workflow / lock-in / hardware revenue line / data
quality — vendor-stated (cite) or Inferred (reasoning shown). Links into
07's business-objective map.

**Platform pairing gaps flagged:** e.g. "mobile-only pairing while web is
the admin surface — deliberate field-workforce scoping — Inferred"

*(repeat the block above per device family)*
```

## File: saas-platform-teardown/assets/report-template/07-integration-architecture.md
size: 1786
sha: 40489560a5381e0bb9efa4d272648e8e971a2ef4
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/07-integration-architecture.md

```text
# 07 — Integration Architecture

> Researched: <date>

## Cross-platform summary

| Platform | Auth model | Data source / API domain | Sync behavior | Notification path |
|---|---|---|---|---|
| Web | | | | |
| Mobile | | | | |
| Desktop | | | | |

Each cell tagged Confirmed / Reported / Inferred.

## Integration business-objective map

Every integration point paired with the PM-level "why" — the column a
decision-maker actually reads. Confirmed = vendor states it (cite the
source); Inferred = deduced, with the reasoning shown.

| Integration point | Technical evidence | Business objective it serves | Tag & reasoning |
|---|---|---|---|
| e.g. Mobile push notifications | FCM permission; "abandoned cart" email schedule in docs | Recover flows started on web | Inferred (push timing matches cart-abandonment windows) |
| e.g. Desktop menu-bar app | tray + global hotkey present; no offline mode | Cut time-to-capture on the core loop → retention | Inferred (…) |
| e.g. Shared auth | same session cookie domain web+desktop | One account, no re-login friction across platforms | Confirmed (docs: <url>) |

## Narrative

2–4 paragraphs: how the platforms actually relate. Is there one primary
platform and companions, or genuine multi-platform parity? Same backend or
separate services? Real-time sync or periodic? Where does the evidence come
from (network domains, status-page incident history, app permissions, docs)?

## Public API & integration ecosystem

- Public API: yes/no, docs URL, auth method
- Webhooks: yes/no
- Official integrations marketplace: count, notable examples
- Zapier / Make / n8n listings: yes/no, links

## Notable mismatches between marketing claims and observed reality

Bullet list, each with the marketing claim and the counter-evidence.
```

## File: saas-platform-teardown/assets/report-template/08-pricing-revenue-sources.md
size: 2126
sha: 1e2f73d1abce45983f8e04141681323799d34a91
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/saas-platform-teardown/assets/report-template/08-pricing-revenue-sources.md

```text
# 08 — Pricing, Revenue & Sources

> Researched: <date>

## Pricing tiers

| Tier | Price | Billing | Headline features | Platform restrictions, if any |
|---|---|---|---|---|
| | | | | |

## Notes on pricing

Anything unusual: usage-based add-ons, per-seat vs. per-workspace, hidden
enterprise tier, features gated by platform rather than by price.

## Revenue & business-scale estimates

Rules this section enforces: every figure shows its method and source;
estimates are labeled estimates; a lone unsourced number is worse than no
number. Almost everything here is an estimate unless the company files with
a regulator — the tags say which.

### Source-by-source estimates

Keep each source's figure separate — never merge estimates from different
sources into one number.

| Source | Figure / range | What it actually measures | Inherent reliability | Tag |
|---|---|---|---|---|
| Owler | | estimated annual revenue | low–medium (algorithmic) | Reported |
| Craft.co / Growjo | | estimated revenue | low–medium (algorithmic) | Reported |
| PitchBook / funding press | | funding = fact; revenue-from-multiple = stage signal | funding high; revenue inference low | Reported |
| LinkedIn estimated revenue | | revenue band | low | Reported |
| Sensor Tower / data.ai / Appfigures | | app revenue / downloads (mobile only) | medium for scale | Reported |
| Similarweb / SEMrush | | monthly visits — a scale indicator, NOT revenue | medium for traffic | Reported |
| Regulator filing (10-K / 20-F / 990) | | actual filed revenue | high — use INSTEAD of estimates when it exists | Confirmed |

### Bottom-up estimate (math shown, assumptions stated)

- Observed pricing tiers: <from the table above — which tiers, which prices>
- Public customer-count claims: <N> — <exact claim wording + source>
- Range math: <e.g. "if most customers sit on the $X/mo tier: N × $X × 12
  = $Y ARR. If even 10% are on the enterprise floor ($Z/yr): + …">
- **Label: estimate.** Shown as math with assumptions — not asserted as
  fact.

## Sources

Flat, deduplicated list of every URL cited anywhere in this report:

-
```

## File: README.md
upstream: https://github.com/ahmedyehya92/saas-platform-teardown-kit/blob/master/README.md

````text
<!-- Centered hero: the logo block intentionally precedes the H1; inline HTML is house style here (MD033 off). -->
<!-- markdownlint-disable MD041 -->
<div align="center">

<img src="assets/logo.svg" alt="SaaS Platform Teardown Kit logo — a magnifying lens examining a sliced-open app window, lid pried off, revealing a hidden gear" width="132"/>

# SaaS Platform Teardown Kit

**One SaaS URL in, a due-diligence-grade teardown out. A Claude Code skill.**

[![CI](https://github.com/ahmedyehya92/saas-platform-teardown-kit/actions/workflows/ci.yml/badge.svg)](https://github.com/ahmedyehya92/saas-platform-teardown-kit/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![Claude Code skill](https://img.shields.io/badge/Claude_Code-skill-D97757)](https://claude.com/claude-code)
[![Version](https://img.shields.io/badge/version-1.0.0-6366F1)](CHANGELOG.md)
[![PRs welcome](https://img.shields.io/badge/PRs-welcome-2EA043)](CONTRIBUTING.md)
[![GitHub stars](https://img.shields.io/github/stars/ahmedyehya92/saas-platform-teardown-kit?style=social)](https://github.com/ahmedyehya92/saas-platform-teardown-kit/stargazers)

[What you get](#-what-you-get) · [Quick start](#-quick-start) · [How it works](#-how-it-works) · [Kit anatomy](#-kit-anatomy) · [Examples](#-example-teardowns) · [FAQ](#-faq) · [Roadmap](#-roadmap) · [Contributing](#-contributing)

</div>

Give it a landing page and it produces a structured, multi-file Markdown
teardown of the whole product: what it does, every feature and user journey
on every platform (web / desktop / mobile), how those platforms integrate —
and the business logic behind those choices — plus hardware coverage,
business-scale/revenue signals, and concrete release artifacts per platform.

Every claim is sourced, dated, and confidence-tagged, so the report tells
you not just what the product looks like but how much of that you should
believe.

## ✨ What you get

Nine linked report files per teardown:

```
<product>-teardown/
├── 00-INDEX.md                    # executive summary + access-methods summary
├── 01-overview-and-recon.md       # + complete verified link inventory
├── 02-web-platform.md             # + access log, journeys
├── 03-mobile-platform.md          # + store artifact tables, access log, journeys
├── 04-desktop-platform.md         # + per-OS/arch artifact table, version history
├── 05-user-journeys.md            # all platforms × 5 journeys, personas, handoff map
├── 06-hardware-integrations.md    # device families — or the explicit none-finding
├── 07-integration-architecture.md # + business-objective map
└── 08-pricing-revenue-sources.md  # + revenue estimates with method per figure
```

**Every claim in the report carries one of three confidence tags** — the
reader always knows how much of it to believe:

| Tag | Means | The reader's move |
|---|---|---|
| 🟢 **`Confirmed`** | Directly observed — screenshot, DOM, API response, official doc | Trust it; check the report date |
| 🟡 **`Reported`** | A secondary source states it — review, forum, press | Re-verify before deciding on it |
| 🟠 **`Inferred`** | Deduced from indirect evidence — reasoning shown, not just the conclusion | Read the reasoning first |

## 🚀 Quick start

### 1 · Pick your tier

Nothing is required to start. Each tier adds capability; every tier
degrades gracefully when missing.

```mermaid
flowchart LR
    T0["🟢 Tier 0 — zero-install<br/>built-in web search + fetch"] --> OUT
    T1["🔵 Tier 1 — live browser<br/>Playwright MCP — UI claims go Confirmed"] --> OUT
    T2["🟣 Tier 2 — parallel sweeps<br/>agy + jq — research fans out"] --> OUT
    OUT(["📦 The same full teardown either way —<br/>missing tools degrade the report honestly,<br/>they never block it"])
```

| Tier | You need | It unlocks | Without it |
|---|---|---|---|
| **0 — zero-install** (default) | Claude Code | Full teardown via the built-in web search/fetch tools; static web audit | — this is the floor |
| **1 — live browser** (recommended) | Playwright MCP — `claude mcp add playwright -s user -- npx @playwright/mcp@latest` | Live in-app exploration, authenticated-state screens, UI claims upgraded to `Confirmed` | Web audit limited to static fetches; UI claims stay `Reported` |
| **2 — parallel research** (optional) | [`agy` CLI](https://antigravity.google/cli/install.sh) + `jq` | The 15 research sweeps fanned out as parallel headless jobs | Same sweeps run sequentially on built-in search — slower, same depth |

### 2 · Install

Tier 0 is one step:

```bash
cp -r saas-platform-teardown ~/.claude/skills/saas-platform-teardown
```

Then restart Claude Code (skills and MCP servers load at session start).
For Tier 1/2 setup — Playwright MCP registration, `agy` permissions, and
the verification snippets — see [setup.md](setup.md).

### 3 · Run it

```
> Do a full platform teardown of https://linear.app
```

or name the skill explicitly:

```
> Use the saas-platform-teardown skill on https://linear.app
```

Claude Code matches the request to `SKILL.md`'s description, works phase
by phase through the reference playbooks, and writes the report folder
under `./<product-slug>-teardown/` in your working directory.

## 🔬 How it works

One URL enters; the kit runs recon first, fans the five research tracks
out in parallel, then closes by synthesizing journeys and assembling the
report (the dashed track is conditional):

```mermaid
flowchart TD
    URL(["🔗 One landing-page URL"]) --> P0["🔍 Phase 0 — intake &amp; recon<br/>tooling check · verified link inventory · sweep questions"]
    P0 --> WEB["🌐 Web audit"]
    P0 --> MOB["📱 Mobile audit"]
    P0 --> DESK["🖥 Desktop audit"]
    P0 --> SWEEP["📡 Research sweeps × 15<br/>stores · pricing · revenue · integrations"]
    P0 -.->|"if a touchpoint is found"| HW["🔌 Hardware deep-dive"]
    WEB --> JOUR["🚶 User-journey synthesis<br/>every platform × journey × persona"]
    MOB --> JOUR
    DESK --> JOUR
    SWEEP --> JOUR
    HW --> JOUR
    JOUR --> ASM["🧾 Report assembly<br/>every claim sourced, dated, confidence-tagged"]
    ASM --> OUT(["📁 product-teardown/<br/>9 linked .md files"])
```

The design principles:

- **One skill, one job, progressive disclosure.** The orchestrator is
  short. Depth lives in `references/`, loaded on demand — the documented
  Claude Code pattern, not an improvised one.
- **Tools do what they're good at.** Live DOM/UI truth comes from the
  configured browser (Playwright MCP when present), not from guessing what
  a page looks like. Broad, fast-moving facts (app store data, pricing,
  revenue estimators, integration directories) are swept by a dedicated
  research pass — fanned out in parallel through `agy` when installed, run
  sequentially on the built-in search otherwise. Claude Code does the
  synthesis, verification, and writing — the part that needs judgment.
- **Decision-grade, not feature-list-grade.** A teardown answers "is this
  product a real threat?": full user journeys per platform, business
  objectives behind every integration, explicit hardware answers,
  revenue/scale signals with methods, and release artifacts per platform —
  not just "an app exists."
- **No credentials is a methodology, not a dead end.** Self-serve trials
  are used when offered; genuinely gated products get the documented
  no-credential ladder (demo videos, help-center screenshots, reviews,
  Wayback, API docs) — and every platform section logs which methods
  produced its claims, so the reader can weigh verified truth against
  secondhand reconstruction.
- **Every claim is sourced or flagged.** The report template forces a
  Confirmed/Reported/Inferred distinction and a source link per section,
  because SaaS products change weekly and an undated, unsourced teardown
  is worthless in three months.

## 📦 Kit anatomy

This is not a single prompt. It's a **skill package** — a short orchestrator
(`SKILL.md`) plus phase-specific reference playbooks, designed around how
Claude Code's Skill
````
