I need to prove this works in a week: how do we POC TinyFish on 100+ sites and measure reliability and step cost?

You’re not trying to “play with a demo.” You’re trying to prove, in one week, that TinyFish can run 100+ sites in parallel, stay reliable, and hit a predictable step cost a CFO won’t flinch at.

This FAQ is the runbook I wish I’d had when I was on the hook for proving a new web data stack could replace fragile Playwright farms and manual ops. It walks through how to structure a 7‑day POC across 100+ sites, what to measure (and how), and how to turn the results into a defensible reliability and cost story.

Quick Answer: In a week, you can POC TinyFish by defining 3–5 repeatable workflows, deploying agents across 100+ sites concurrently, and tracking success rate, median runtime, and cost per step via the API and Workbench. You measure reliability as successful full runs / total runs and step cost as total spend / total executed steps.

---

Frequently Asked Questions

How do I design a 1‑week POC on 100+ sites that actually proves TinyFish works?

Short Answer: Treat the POC like a mini-production rollout: pick 3–5 real workflows, map them to 100+ target sites, define success criteria (success rate, runtime, step cost), and run them in parallel at least daily.

Expanded Explanation:
The failure mode for most “AI agent” trials is that they test toy flows on 2–3 easy sites, then extrapolate to a world of hostile auth, CAPTCHAs, and weird DOMs. That tells you nothing about production reality. For TinyFish, the right POC is breadth + depth: breadth across your target site types (carriers, marketplaces, portals, etc.) and depth across the actual steps you care about (logins, filters, quote forms, checkout totals).

You want a design that surfaces three truths quickly:

1. Can TinyFish reach and complete workflows behind logins, forms, and anti-bot?
2. Can it run 100+ of those concurrently without falling over or getting throttled?
3. Can you model step-level cost in a way that scales to thousands or millions of runs?

That means you define a small set of canonical workflows, replicate them across your 100+ sites, and push them hard for a week—measuring every run.

Key Takeaways:

• Don’t POC “hello world”; POC the hardest realistic flows you’d run in production.
• Design around clear metrics: success rate, runtime, concurrency, and cost per step.

---

What’s the process to set up TinyFish on 100+ sites within a week?

Short Answer: Standardize workflows first, then scale targets: define reusable agent templates, plug in site-specific parameters (URLs, credentials, identifiers), and deploy them in parallel using the TinyFish API and Workbench.

Expanded Explanation:
You’re not going to custom-script 100+ sites in 7 days. You don’t need to. TinyFish is built for pattern-based workflows where the skeleton is the same and only the parameters change. Think: “log in → navigate to product or policy → apply filters → extract structured outputs → (optionally) transact.”

Use that to your advantage:

• Build 3–5 agent templates that capture your most critical workflows.
• Maintain a site catalog (CSV or DB) with per-site variables (login URL, credentials handle, item identifiers, locale).
• Drive everything via a simple orchestration loop that spins up 100+ agents concurrently.

TinyFish handles the heavy lifting—browser orchestration, authentication, CAPTCHAs, anti-bot—so your setup is about defining the goal and outputs, not juggling Selenium nodes and proxies.

Steps:

1. Define 3–5 core workflows
   Examples:

   • Authenticated pricing or quote retrieval
   • Availability or eligibility checks across portals
   • Checkout to receipt-level totals (fees, taxes, discounts)
     For each: write down the step sequence and the structured fields you need back.

2. Create agent templates in TinyFish

   • Use the API to define your agent: goal, navigation hints, expected outputs.
   • Parameterize what varies per site (URLs, selectors when needed, locale, product IDs).
   • Test each template on 2–3 representative sites before scaling.

3. Scale to 100+ sites via orchestration

   • Build a simple job runner (or use your existing workflow engine) that reads your site list and fires TinyFish runs concurrently (dozens to hundreds at a time).
   • Track run IDs, timestamps, and outcomes using Workbench and/or your own logs.
   • Run each workflow at least 2–3 times per site across the week to validate consistency.

---

How does TinyFish compare to traditional automation or search for a high-pressure POC like this?

Short Answer: Traditional automation can eventually reach similar sites but is slow and brittle at scale; search is fast but stale. TinyFish combines live execution behind logins with sub‑minute production speed and parallelism across 1,000+ agents.

Expanded Explanation:
If you’ve ever kept a Playwright/Selenium + proxy + CAPTCHA stack alive, you know the trade-offs:

• It can reach portals, but concurrency kills it—costs spike, and uptime falls.
• Every DOM tweak becomes a fire drill. Your team becomes a ticket queue for “broken scripts.”
• You get live data, but not at production speed (think 45 minutes+ for dozens of portals).

Search is the opposite: lightning fast, but cached and blind to anything behind auth, forms, or paywalls. For work that depends on live pricing, eligibility, or availability, cached is dangerous.

TinyFish is built specifically to avoid that trade-off:

• Live execution: Agents actually log in, click, fill forms, and transact in real time.
• Concurrency: Scale from 1 to 1,000+ parallel agents without touching infra.
• Speed: Production speed in the sub‑minute range for typical multi-step flows.
• Coverage: Supports sites behind logins, forms, paywalls, bot detection.

For a POC, that means you can hit 100+ sites at once and still measure production-like performance and reliability, not lab numbers.

Comparison Snapshot:

• Option A: TinyFish (Web Agents / Search Agents)
  Live execution behind logins, 1,000 simultaneous ops, sub‑minute runs, structured outputs via API, enterprise controls baked in.
• Option B: Traditional automation or search
  Automation: live but slower, brittle, and expensive at scale.
  Search: fast but cached/stale, limited to indexed public content.
• Best for: Proving you can run 100+ authenticated workflows at production speed with predictable cost per operation.

---

How do I actually measure reliability and step cost during the POC?

Short Answer: Track run-level outcomes (success/failure, reason), count steps per run, and aggregate: reliability = successful runs / total runs; step cost = total TinyFish spend / total executed steps.

Expanded Explanation:
Your stakeholders don’t care that an agent “looks cool.” They care that it works reliably across messy sites and that you can price each workflow in dollars per step.

TinyFish gives you the hooks to measure both:

• Reliability: For each agent run, you can see:

  • Did it complete all steps and return structured outputs?
  • If it failed, at which step and why (auth issue, anti-bot response, unexpected page state)?
  • Over time: % of runs that fully succeed per site, per workflow, per day.

• Step cost: TinyFish pricing is based on steps executed (e.g., navigation, form submit, extraction). For cost modeling:

  • Count steps per successful run (you’ll see typical patterns like 25–40 steps for complex quote or checkout flows).
  • Multiply by your unit price per step (e.g., $0.015/step as a reference unit).
  • That gives you cost per completed workflow and per site.

For a 7‑day POC, you want to come out with clear, audit-friendly numbers:

• “Over 100 sites, we ran 2,500 workflows.”
• “Our success rate was 98–99% on steady-state runs.”
• “Median workflow: 32 steps, $0.48 per complete run.”
• “End-to-end runtime: median 45 seconds.”

What You Need:

• Instrumentation:
  • Log each TinyFish run with: site, workflow type, run ID, start/end time, success flag, failure reason, step count.
  • Use TinyFish Workbench for quick visibility and screenshots; export data for deeper analysis.
• Cost mapping:
  • Understand your negotiated TinyFish step pricing.
  • Multiply step counts by price and roll up by workflow and site to show a clear unit cost.

---

How do I frame the POC so leadership sees real strategic value—not just a technical demo?

Short Answer: Tie the POC to specific business outcomes (faster time-to-truth, lower manual ops, fewer outages from brittle automation) and show how TinyFish shifts you from cached or manual data to live execution at production scale and predictable cost.

Expanded Explanation:
A week is enough time to prove directionally whether this platform changes your operating model. Your leadership wants to know: does this get us out of the trap of stale data, broken scripts, and 3–5 day manual cycles?

Align the POC story around three vectors:

1. Speed to “web truth”

   • Benchmark TinyFish vs your status quo on a real task (e.g., 50–100 portals).
   • Use simple numbers:
     • TinyFish: live extraction, sub‑minute per workflow, 1,000 simultaneous.
     • Traditional automation: ~45+ minutes for 50 portals.
     • Manual: 3–5 days.
   • Emphasize that TinyFish delivers production-speed, live results—not cached indexes.

2. Reliability and operational risk

   • Highlight measured success rate (TinyFish typically hits ~98.7% in production) vs your current failure rate.
   • Show that TinyFish runs unattended in the cloud:
     • No browsers to manage.
     • No proxies to rotate.
     • No in-house CAPTCHA stack.
   • Call out enterprise reliability and governance: 99.99% uptime, encryption (AES‑256 at rest, TLS 1.3 in transit), SSO, audit logs.

3. Unit economics and scalability

   • Present cost per completed workflow and per site, backed by real POC data.
   • Show how AI-driven adaptive runs can be codified into deterministic, cheaper execution as workflows stabilize over time.
   • Contrast with your current stack: multiple bills (browsers, proxies, LLMs, infra) vs TinyFish’s “one price, everything included” model.

Why It Matters:

• You’re not just replacing a tool; you’re replacing how your org gets live web data—for pricing, availability, eligibility, risk.
• A clear 7‑day POC with reliability and cost metrics lets you make a production decision with confidence instead of hope.

---

Quick Recap

In one week, you can run a meaningful POC across 100+ sites by standardizing 3–5 real workflows, turning them into TinyFish agent templates, and deploying them across your site list in parallel. Use the TinyFish API and Workbench to track success rate, runtime, and steps per run. Reliability is simply successful runs over total runs; step cost is total spend divided by total steps. Present the results as a production story: sub‑minute live execution, 1,000+ concurrent agents, ~98–99% success on real portals, and a clear cost per workflow that beats brittle automation and 3–5 day manual cycles.

Next Step

Get Started