Your First Flow: The Full Snap Studio Walkthrough¶

Audience: Everyone · Tags: snap-studio, flows, walkthrough, deep-dive

This is the definitive, in-depth walkthrough of Snap Studio, SnapLink's guided flow builder. If Quick Start got you a working flow in ten minutes, this page explains why each step works the way it does, so you can build flows confidently on your own. Open Studio at /snap in the app and follow along.

Studio has three stages: Describe it → Review & edit → Save & test. You always move through them in order, and you can always go back to an earlier stage before you save.

Stage 1 — Describe it¶

This stage is a single text box and a Submit (or Draft it) button, plus a handful of example chips you can click if you'd rather start from a suggestion than a blank page.

Writing a good description¶

You don't need special syntax. Write the way you'd explain it to a coworker: what should trigger the flow, and what should happen as a result. A few examples:

"When my link gets a message, email it to me at ops@example.com."
"When my link receives a message, post it to Slack."
"When a webhook comes in, send it to my REST endpoint."

Today, every flow's trigger is a webhook — a private web address that other systems send information to. You don't need to say "webhook" explicitly; describing "when my link gets a message" or "when something comes in" is enough for the assistant to infer it, because it's the only trigger type available right now.

Be specific about the action's destination. "Email it to me" is vague — "email it to me at ops@example.com" tells the assistant exactly what to fill in. The more concrete you are, the less you'll need to fix in Stage 2.

How the plan gets drafted¶

When you submit, SnapLink's drafting assistant turns your sentence into a structured plan: a trigger and one or more actions. It's produced by one of two engines, and Studio always tells you honestly which one did the work:

engine: "llm" — a large language model (Claude, via your operator's configured AI provider) interpreted your description.
engine: "rules" — a deterministic, rule-based planner was used instead. This happens when no AI model is configured for your workspace, or the model is temporarily unavailable. It still produces a usable plan from common phrasings — just without the flexibility of a language model.

Whichever engine drafts it, the same rule applies: SnapLink's assistant drafts flows for you. It never turns anything on, never runs anything, and never sees your credentials. You review and approve every flow before it exists. Nothing is saved and nothing runs until you explicitly save it in Stage 3.

Stage 2 — Review & edit¶

Your plan renders as a stack of step cards:

One WHEN card — your trigger.
One or more THEN cards — your actions, in the order they'll run.

Each card shows plain-language form fields (not raw JSON), with help text under each one explaining what it's for. For an email action, for instance, you'll see fields like "Send to," "Subject," and "Message," each with a short explanation and, where relevant, an example.

"I need to know" prompts¶

If the assistant couldn't confidently fill in a required field from your description — say, you never mentioned an email address — that field comes back empty or flagged, with help text phrased as a direct question: "I need to know: which email address should receive this?" Fill it in the same way you'd fill in any other field. There's nothing hidden here — every question the assistant has is asked plainly, next to the exact field it concerns.

Editing the plan¶

Nothing is locked. Change any field's value, edit the wording of a message, fix an address, or adjust which channel or endpoint an action targets. You're not just approving the assistant's guess — you're the one who decides what the flow actually says and does.

Keep in mind what a SnapLink action can and can't do today: the message an action sends is fixed text you write in the card. Actions don't currently pull fields out of the incoming trigger data and insert them into the message automatically — if you want specific details in your email or Slack message, write them into the text yourself.

Check my flow¶

When your fields look right, click Check my flow. This runs a design-time validation pass over the whole plan — no messages are sent, nothing runs. If it finds a problem, it reads the issue back to you in a plain sentence tied to the exact step and field responsible, for example: "Step 2 (Send email): 'Send to' is missing an email address." Fix what it flags and check again. You can check as many times as you like before moving on.

Built for everyone¶

Studio is designed to work fully with a keyboard and a screen reader, not just a mouse:

A single shared status region announces what's happening (using aria-live="polite"), so screen reader users hear updates without losing their place.
Moving between stages moves keyboard focus straight to that stage's heading.
A validation error moves focus to the first invalid field and announces what's wrong.
Every status is shown as an icon plus a word — never color alone — so it reads correctly regardless of how you perceive color.
If your system is set to reduce motion, Studio's step-reveal animation becomes instant instead of animated.
Every control is reachable and operable by keyboard alone, with a visible focus outline.
Buttons and other click targets are at least 44 pixels, and body text is at least 16 pixels, so the interface is comfortable to use precisely.

Stage 3 — Save & test¶

Once Check my flow comes back clean, move to Stage 3. Click Save & test. This single action does two distinct things:

It persists the flow. SnapLink saves your trigger and actions as a real flow definition your workspace owns — the same kind of definition you could inspect or edit later.
It runs the flow once, for real. This is not a dry run or a simulation — it's a genuine execution through SnapLink's execution engine, exactly like a run that will happen automatically once the flow is active and its trigger fires.

While it runs, Studio narrates progress step by step, in plain language, as each one completes:

Step 1 — Sending an email: done

If your flow has more than one action, you'll see each one narrated in turn, in order.

On success¶

Every step reports done, and the effects are real: an email lands in the inbox you specified, a Slack message posts to the channel you chose, and so on. Go check the destination — that confirmation is the real proof, not just the on-screen status.

On failure¶

If a step doesn't succeed, Studio shows you a plain-language cause — not a raw error code or stack trace — plus a "How to fix it" suggestion telling you what to change. Common causes include a missing or expired credential, an invalid destination address, or a destination that refused the request. Fix the flagged field and click Save & test again; you don't need to start over from Stage 1.

What "saved" actually means¶

A flow you've saved through Studio has a version, just like any SnapLink flow. If you come back later and change it, SnapLink creates a new draft version and you promote it when you're ready — Studio handles this for you automatically when you edit and re-save. Under the hood, every flow definition is simply a trigger and a list of actions, each naming the connector and action type it uses and the input fields you filled in.

After your first flow¶

Once your flow is saved, it's ready to be triggered from the outside world at its own private webhook address — see Your First Success if you haven't already tried Quick Send, and check your Runs history any time to see every execution your flow has produced, with its status and timeline.

If something goes wrong¶

Plan won't validate → check the message from Check my flow; it names the exact step and field.
Save & test fails → read the plain cause and "How to fix it" note on the failed step, then see Execution failures and Connector failed.
Nothing seems to happen after saving → see Flow not running.
A credential or connection problem → see Authentication errors.

Was this helpful? 👍 👎