Most first Gumloop flows fail for the same reason: they’re too big. Someone drags ten nodes onto the canvas, wires Gmail into Slack into a scraping step into an AI node, then spends ninety minutes chasing a block that keeps truncating its own output. The second attempt usually works, because by then they’ve picked something small.
This walkthrough skips the first attempt. You’ll build a working flow in roughly half an hour using a task almost every team already has lying around: monitoring something on the web and summarising what changed. If you’d rather start with the bigger picture of what the platform is actually for, this explanation of Gumloop as a no-code automation tool for busy teams is a useful detour before you start clicking.
Choose a task that’s boring, repeated, and text-heavy
The temptation is to automate the hardest thing on your plate. Don’t. For a first flow, look for a task that ticks three boxes:
- It happens on a schedule: daily, weekly, or every time a form is submitted.
- It involves reading or skimming text and writing a short summary of it.
- The result goes somewhere you already look, such as a Slack channel or a spreadsheet.
Competitor pricing checks, inbound lead research, support ticket triage, and weekly newsletter roundups all qualify. The example I’ll use throughout: a 40-person B2B software company that wants to know when a rival changes its pricing page. Right now that job eats about four hours a week across two people, and half the time nobody notices the change until a customer asks about it.
Step 1: Write your desired output before you open the canvas
Skip this and you’ll build a flow that produces something technically correct and practically useless. Write the exact message you’d want to receive, in plain English:
Two to five bullets. Each names the competitor, what changed, and the old versus new figure. Send nothing at all if no page changed.
That single sentence does three jobs. It defines what the AI node should return, it tells you when the flow should stay silent, and it gives you something concrete to test against later.
Step 2: Build the trigger first
Every flow starts with a trigger, and the obvious choice for a monitoring job is a schedule. Set it to Monday at 7am, before anyone opens a laptop. Other triggers behave the same way, whether that’s a webhook, a new row in a Google Sheet, a Slack message, or an inbound email. If your task is event-driven rather than calendar-driven, swap one in here. The reason to build the trigger first is simple: you can run the flow on demand while developing it, and the schedule is already waiting when you finish.
Step 3: Feed it the inputs
Now list the pages you’re watching. A Google Sheets node reading a single column does the trick: 32 URLs, one per row. From there, a loop node steps through the list and a web scraping node pulls the live content of each page. This is where the node model earns its keep. Each block does one thing and hands the result to the next, and you can click into any node to inspect exactly what it received. When something looks wrong three steps later, you know precisely where to look.
Step 4: Let one AI node do the thinking
Give a single AI node the scraped text and a prompt that matches the output you wrote in step one. Three things separate a prompt that holds up from one that drifts:
- A role and a constraint. “You are comparing a competitor pricing page against last week’s snapshot. Report only material changes.”
- A structured return. Ask for a fixed set of fields, such as competitor, changed element, old value, new value, so the next node handles it without guessing.
- A rule for uncertainty. Tell it to return “no change” rather than inventing a difference, because a confidently hallucinated price change costs you more trust than a missed one.
If you’re unsure how to phrase any of that, the built-in assistant will draft the whole flow from a plain-English description, which beats staring at a blank canvas. Treat its output as scaffolding. You still want to read every prompt it writes.
Step 5: Send the result where humans already look
Wire the final node to Slack, or back into the sheet, or both. During week one, route it to yourself. You want a couple of real runs before the whole team sees it. That’s how you catch a scraper that’s picking up cookie banners instead of prices. Once two consecutive runs look right, point it at the team channel and let it run quietly in the background.
What the finished flow actually does
The build above takes about half an hour and runs in roughly three minutes. It checks 32 pages, compares each against the stored snapshot, and posts a message only when something moved, which happens two to five times a month. The four hours of manual checking drop to zero, and the alert arrives before anyone thinks to ask.
That ratio is the entire argument for small, boring flows. They don’t look impressive on a demo call, and nobody writes a case study about a pricing monitor. They just quietly delete a recurring chore, every week, forever.
Five mistakes that break first-time flows
- Bundling two jobs into one. Scraping and summarising belong in separate nodes. A single mega-prompt fails in ways that are hard to diagnose.
- Forgetting the empty case. A flow that posts “no changes found” every Monday gets muted by week three.
- Testing with one input. Run the loop over at least five rows before you trust it, including one deliberately broken URL.
- Ignoring credit cost. Loops multiply usage, so a 500-row sheet with three AI calls per row behaves very differently from a 20-row sheet.
- Skipping the human. Keep an approval step for the first fortnight, especially if the output reaches customers.
Then build the second one, and the third
Once a flow has run clean for two weeks, the useful next move is to break parts of it into a subflow you can reuse. The scrape-and-compare pattern you just built works for job boards, changelog pages, regulatory filings, and competitor hiring pages with about ten minutes of edits each time. Teams that reach this stage end up with a small library of automations rather than one flagship flow, which is closer to how AI is quietly reshaping everyday work than anything you’ll see in a keynote.
It also explains why so much attention is flowing into this corner of software, and why the money follows, as the lineup around Benchmark’s main stage appearance at Disrupt 2026 suggests. None of that matters much on a Tuesday morning when your pricing alert fires and you’re the first person in the company to know. Build the small flow. The impressive ones can wait.