# FetchCatch overview

FetchCatch is a **decision automation platform** for SaaS teams who need runtime rules, workflows, and integrations — without hard-coding every branch or adopting a full BPM suite.

You design **decision flows** in a visual console, connect them to your existing HTTP APIs (via OpenAPI), and expose each flow as a single HTTP endpoint your apps can call. Flows can **pause** when they need a human in the loop, then **resume** when the user completes a form or an external system sends an event.

## What problems does it solve?

| Problem | How FetchCatch helps |
|---------|----------------------|
| Business rules scattered in code | Centralize rules as versioned flows |
| Ops wants to change logic without deploys | Edit in console or sync JSON from git |
| Multi-step approvals with waiting | Native pause/resume with durable state |
| Calling many internal APIs per decision | Drag OpenAPI operations as graph nodes |
| AI assistants editing rules in repos | CLI sync + documented JSON schemas |

## The three surfaces

### 1. Web console

Sign up at [fetchcatch.com](https://fetchcatch.com), create a workspace, and use the flow designer to build graphs. Configure API sources, auth profiles, response types, and API keys — all from the browser.

→ [Using the console](console-guide.md)

### 2. CLI (`fcc`)

Sync flows to your repository as JSON under `.fetchcatch/`. Review changes in pull requests, apply from CI, and let coding agents edit rules with guardrails.

→ [CLI reference](cli-reference.md) · [Sync & CI](sync-and-ci.md)

### 3. Evaluate API

Call published flows from your backend or edge functions:

```
POST https://api.fetchcatch.com/v1/evaluate/{flowSlug}
Authorization: Bearer {apiKey}
```

→ [Evaluate API](evaluate-api.md)

## Typical journey

```
1. Sign up → create workspace
2. Add an API source (your OpenAPI spec)
3. Design a flow in the console
4. Define a response type (optional but recommended)
5. Publish the flow
6. Create an API key
7. Call /v1/evaluate from your app
```

For teams using git:

```
fcc init → fcc login → fcc pull → edit JSON → fcc apply
```

## Architecture at a glance

```
Your app ──POST /v1/evaluate──► FetchCatch API ──► Flow interpreter
                                      │
                                      ├──► Your HTTP APIs (OpenAPI nodes)
                                      ├──► SQL (durable run state)
                                      └──► Pause until resume event
```

- **Tenant** — your organization; isolated data and secrets
- **Workspace** — a project within a tenant (e.g. `payments`, `onboarding`)
- **Flow** — a decision graph with a slug used in the evaluate URL
- **Run** — one execution of a flow; may complete or pause
- **Response type** — schema for what a flow returns

→ [Core concepts](concepts.md)

## Documentation versions

This is **documentation v0.1**, matching flow JSON `schemaVersion: 1`. When schemas change, a new doc version is published alongside; see [manifest.json](https://fetchcatch.com/docs/manifest.json).

## Where to go next

| I want to… | Read |
|------------|------|
| Get up and running | [Getting started](getting-started.md) |
| Understand tenants, flows, runs | [Core concepts](concepts.md) |
| Build flows visually | [Flow designer](flow-designer.md) |
| Sync flows to git | [Workspace layout](workspace-layout.md) |
| Decide who can publish (console vs CLI) | [Governance modes](governance.md) |
| Promote flows across dev / staging / prod | [Environments](environments.md) |
| Call flows from code | [Evaluate API](evaluate-api.md) |
| Use the typed .NET client | [.NET SDK](dotnet-sdk.md) |
| Configure Cursor / AI agents | [AI agent guide](ai-agent-guide.md) |