⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

saas-platform-teardown

ahmedyehya92@ahmedyehya92⭐ 20 stars· last commit 2mo ago· 0 open issues

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 M

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 20 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

SaaS Platform Teardown Kit

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

CI License: MIT Claude Code skill Version PRs welcome GitHub stars

What you get · Quick start · How it works · Kit anatomy · Examples · FAQ · Roadmap · Contributing

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:

TagMeansThe reader's move
🟢 ConfirmedDirectly observed — screenshot, DOM, API response, official docTrust it; check the report date
🟡 ReportedA secondary source states it — review, forum, pressRe-verify before deciding on it
🟠 InferredDeduced from indirect evidence — reasoning shown, not just the conclusionRead the reasoning first

🚀 Quick start

1 · Pick your tier

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

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"])
TierYou needIt unlocksWithout it
0 — zero-install (default)Claude CodeFull 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@latestLive in-app exploration, authenticated-state screens, UI claims upgraded to ConfirmedWeb audit limited to static fetches; UI claims stay Reported
2 — parallel research (optional)agy CLI + jqThe 15 research sweeps fanned out as parallel headless jobsSame sweeps run sequentially on built-in search — slower, same depth

2 · Install

Tier 0 is one step:

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.

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):

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

// HOW IT'S BUILT

// FILES

19 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • saas-platform-teardown/SKILL.md11 KB127b75ecf29cupstream ↗
    ---
    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.
    
  • saas-platform-teardown/references/01-intake-and-recon.md6.3 KB4d249ba7f917upstream ↗
    # 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.
    
  • saas-platform-teardown/references/02-web-platform-audit.md10 KBbaceb09038d7upstream ↗
    # 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.
    
  • saas-platform-teardown/references/03-mobile-platform-audit.md6.0 KBd205e83cdd00upstream ↗
    # 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.
    
  • saas-platform-teardown/references/04-desktop-platform-audit.md5.7 KBe0fe62f3b1b5upstream ↗
    # 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.
    
  • saas-platform-teardown/references/05-integration-architecture.md7.1 KBf1355564303fupstream ↗
    # 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.
    
  • saas-platform-teardown/references/06-research-sweeps.md13 KB9ab1abd39988upstream ↗
    # 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.
    
  • saas-platform-teardown/references/07-report-assembly.md4.9 KBa5ec235995d5upstream ↗
    # 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.
    
  • saas-platform-teardown/references/08-hardware-integrations.md5.3 KB4b59b29a9fcbupstream ↗
    # 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.
    
  • saas-platform-teardown/assets/report-template/00-INDEX.md2.3 KBca031510df3cupstream ↗
    # <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.
    
  • saas-platform-teardown/assets/report-template/01-overview-and-recon.md2.1 KB6d2af6a26a97upstream ↗
    # 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 | | |
    
  • saas-platform-teardown/assets/report-template/02-web-platform.md1.5 KBbefb6ed8a688upstream ↗
    # 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.
    
  • saas-platform-teardown/assets/report-template/03-mobile-platform.md2.4 KB6810df3950eeupstream ↗
    # 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).
    
  • saas-platform-teardown/assets/report-template/04-desktop-platform.md2.5 KB8d2c678a8735upstream ↗
    # 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.
    
  • saas-platform-teardown/assets/report-template/05-user-journeys.md2.5 KBda3060ecabc2upstream ↗
    # 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 |
    |---|---|---|---|
    | | | | |
    
  • saas-platform-teardown/assets/report-template/06-hardware-integrations.md1.5 KB0361b5300e36upstream ↗
    # 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)*
    
  • saas-platform-teardown/assets/report-template/07-integration-architecture.md1.7 KB40489560a538upstream ↗
    # 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.
    
  • saas-platform-teardown/assets/report-template/08-pricing-revenue-sources.md2.1 KB1e2f73d1abceupstream ↗
    # 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:
    
    -
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/ahmedyehya92-saas-platform-teardown-kit-saas-platform-teardown.md

// REPO STATS

20 stars
0 open issues
Last commit: 2mo ago