# Latenode Tutorial (2026): Build Two Real Automations, Step by Step > A hands-on Latenode tutorial: create a free account, learn the canvas, and build two real automations step by step — an AI lead classifier and a scheduled scrape-and-summarize — plus the AI Copilot, the HTTP node, and the debugging habits beginners need. _Source: https://professionalstoolkit.com/articles/latenode-tutorial — The Professional's Toolkit · updated 2026-07-29_ --- > **TL;DR —** This is a hands-on Latenode starter: create a free account, learn the canvas, build two real scenarios step by step, and pick up the debugging habits that save you time. You'll build an **AI lead-classifier** (webhook → AI model → data store) first, then a **scheduled web-scrape-and-summarize** using the JavaScript node and the headless browser. Along the way you'll use the **AI Code Copilot** to generate and fix logic, and you'll learn the one mental shift that keeps costs low: because Latenode bills **CPU-seconds (compute time)**, you optimize for *speed*, not step count. The free plan (10,000 CPU-seconds, no card) is more than enough to follow every step here. Budget an afternoon; the docs lag in places, so we call out exactly where beginners get stuck. ## Before you start Sign up at the Latenode site — the **Free plan needs no credit card** and gives you 10,000 CPU-seconds a month, five active workflows, and the AI features on trial. That's plenty to complete this whole tutorial with room to spare. One concept to internalize before you build anything, because it shapes every decision that follows: **Latenode charges for compute time, not steps.** A workflow with twenty nodes that finishes in five seconds costs the same as a two-node one that also takes five seconds. So as a beginner you don't need to be precious about adding nodes for clarity — add them freely. What you *do* watch is slow work: a node that waits 30 seconds on a sluggish API costs far more than ten fast nodes combined. Build for readability; optimize for speed only where a step is genuinely slow. ## The canvas in two minutes Latenode is a visual drag-and-drop builder. Three things make up almost everything you'll do: - **Triggers** start a scenario — a webhook, a schedule, an app event, or a manual "run once" for testing. - **Action nodes** do the work — call an app, run an AI model, transform data, branch on a condition, loop, or write to the built-in database. - **The JavaScript node** is the escape hatch: any node can run real JS with the **entire NPM ecosystem** available (packages auto-install), so when the no-code path runs out, you write your way through. Off to the side sits the **AI Code Copilot** — a chat assistant that can generate workflow logic, write the code inside a JS node, and read your scenario to suggest fixes. New builders should lean on it early; it's the fastest way past the documentation gaps. ## Scenario 1 — an AI lead classifier (webhook → AI → data store) Goal: when a new lead hits a webhook, an AI model tags it (hot / warm / cold) and the result is saved. This teaches triggers, the built-in AI models, and the data store — the three things you'll reuse constantly. **Step 1 — add a webhook trigger.** Create a new scenario, drop a **Webhook trigger** as the first node, and copy the URL it generates. Send it a test payload (Latenode gives you a "listen for test request" button) with a sample lead: name, company, message. Run once so the node captures the shape of the incoming data — every downstream node will reference these fields. **Step 2 — add an AI model node.** Drop an **AI node** and pick a model from the 1,200+ available (start with a fast, cheap one — you don't need a frontier model to classify a sentence). No separate API key is required; the models are built in. In the prompt, reference the incoming message with Latenode's variable picker and instruct it plainly: *"Classify this lead as hot, warm, or cold based on buying intent. Reply with one word only."* Constraining the output to one word makes the next step trivial. **Step 3 — save the result.** Add a **Data Store** (the built-in database) node, or an app node if you'd rather write to a Google Sheet or CRM. Map the fields: lead name, company, and the AI's one-word classification. This is where the "one word only" instruction pays off — you store a clean value, not a paragraph. **Step 4 — test end to end.** Fire the webhook again with a realistic message and watch the run. You should see the lead flow in, the AI return a tag, and the row land in your store. Total run time is a couple of seconds — a couple of CPU-seconds — so you could run this thousands of times a month and stay inside the free tier. That's a genuinely useful automation built from three nodes. Now let's use the parts that make Latenode different from a pure no-code tool. ## Scenario 2 — scheduled scrape and summarize (schedule → headless browser → JS → AI) Goal: every morning, pull a page, extract the part you care about, and get an AI summary in Slack (or email). This teaches the schedule trigger, the **headless browser**, the **JavaScript node**, and chaining AI onto real data. **Step 1 — schedule trigger.** Add a **Schedule trigger** set to once a day. For testing, use "run once" instead of waiting for the clock. **Step 2 — headless browser node.** Point it at the page you want. The headless browser renders the page (including JavaScript-heavy sites a simple HTTP request can't handle) and returns the HTML or the specific content you target. This is a capability many no-code tools simply don't have. **Step 3 — JavaScript node to extract.** Here's where the escape hatch earns its keep. Drop a **JavaScript node** and write a few lines to pull out the text you want — parse the HTML, grab the elements, clean the string. Don't know the exact code? Ask the **AI Copilot**: *"Given HTML in the input, extract all article headlines into an array."* It writes the node for you; you tweak and run. If you need a parsing library, `import` it — NPM packages auto-install. **Step 4 — AI summarize.** Feed the extracted text into an **AI node**: *"Summarize these headlines into three bullet points a busy manager can skim."* Then add a **Slack** (or email) node and post the summary. Run once, confirm the message lands, then enable the schedule. Now you've used the two things that define Latenode as a *builder's* tool — real code and a real browser — inside a visual flow, with AI doing the heavy lifting at both ends. ## Scenario 3 — connect an app that has no native node (the HTTP node) Sooner or later you'll want to connect a tool Latenode doesn't have a click-to-connect node for. Rather than a dead end, this is a five-minute detour with the **HTTP node** — worth learning early, because it turns "unsupported app" into "any app with an API." **Step 1 — find the app's API endpoint and auth.** Almost every SaaS tool documents a REST API. Grab the endpoint URL, the method (usually GET or POST), and how it authenticates (an API key in a header is the common case). **Step 2 — configure the HTTP node.** Drop an **HTTP Request node**, set the method and URL, add the auth header, and — for a POST — build the JSON body using the variable picker to pull in data from earlier nodes. If you're unsure how to shape the body, paste the app's API example into the **Copilot** and ask it to build the request. **Step 3 — run and map the response.** Fire it once and inspect the response in the run log. The JSON that comes back is now available to every downstream node, exactly like a native connector's output. Save the request as a **reusable custom connector** if you'll use it again — you build it once and reuse it across scenarios. That's the pattern that closes most native-connector gaps for niche tools: native node where one exists, HTTP node where it doesn't, and the response feeds the rest of your flow either way. ## Reuse what you build Once you're past your first few scenarios, three features stop you repeating yourself: - **Custom connectors** — turn an HTTP request or a bit of logic you use repeatedly into a named, reusable node. Build the awkward API call once; drop it into every scenario that needs it. - **Sub-scenarios** — factor a common sequence (say, "enrich a contact") into its own scenario and call it from others, so a fix in one place propagates everywhere. - **Global variables** — store API keys, base URLs and shared settings once instead of pasting them into every node. Change the value in one place when it rotates. Reaching for these early keeps a growing collection of automations maintainable rather than a pile of copy-pasted nodes. ## Handle errors before they bite A scenario that works in testing can still fail in production when an external API times out or returns something unexpected. Two habits make your automations resilient: - **Add a fallback path on risky nodes.** For a step that calls an external service, branch on failure — retry once, or route to a "notify me" node — so one flaky API call doesn't silently drop data. - **Validate incoming data early.** If a webhook can send a malformed payload, add a small **JavaScript** or condition node right after the trigger to check the fields exist before the rest of the flow assumes them. It's the single most common cause of "it worked yesterday" failures. ## Using the AI Code Copilot well The Copilot is the beginner's biggest lever on Latenode, precisely because the docs don't cover everything. Two habits: - **Generate, then read.** Ask it to build a node or a JS snippet, but read what it produces before running — you learn the platform faster, and you catch the occasional wrong assumption about your data shape. - **Debug with it.** When a node errors, paste the error (or point the Copilot at the scenario) and ask what's wrong. It reads the context and suggests a fix. This is far faster than hunting through documentation that may not describe your exact case. ## Common beginner mistakes (and how to avoid them) A few things trip up almost everyone starting out — worth knowing before they cost you an afternoon: 1. **Treating it like a per-step tool and under-building.** Old habits from step-metered platforms make people cram logic to save "steps." On Latenode that's backwards — add nodes freely for clarity; only *slow* nodes cost. The one real cost mistake is leaving a needlessly slow node (a long wait, an unbatched loop) in a high-frequency workflow. 2. **Fighting the expression system on complex data.** Latenode's block-style expressions and data-passing between nodes can feel rigid for elaborate, dynamic AI workflows — reviewers flag this as a genuine friction point. The fix is pragmatic: when the visual expressions get awkward, drop into a **JavaScript node** and handle the data shaping in code. It's almost always cleaner than wrestling the block editor. 3. **Expecting a native connector for everything.** Latenode's catalog is broad (the vendor lists 1,200+ apps), but a niche or uncommon app may still not have a click-to-connect node. Reach for the **HTTP node** or a JS `fetch` — with code and 1,200+ AI models, you can reach almost anything, but confirm your must-have apps early so there are no surprises. 4. **Skipping the run history when something breaks.** Beginners re-run blindly instead of reading what actually happened. Don't — the run log tells you exactly which node failed and with what data. ## Debugging, concretely When a scenario misbehaves, work in this order: - **Open the run history.** Every execution is logged; click into the failed run and you'll see each node's input and output. The failure is almost always visible as a node that received the wrong data shape, not a mysterious platform bug. - **Test one node at a time.** Use "run once" and inspect the output of each node before wiring the next. Catching a malformed field at node 2 is far cheaper than discovering it at node 8. - **Ask the Copilot to read the error.** For code and expression errors especially, it's faster than the docs. - **Watch run duration as a cost signal.** If a workflow you'll run often is taking tens of seconds, find the slow node now — it's both a performance and a billing issue, and fixing it (batching, caching, a lighter model) pays off every single run. ## Where to go next You've now built two real automations and learned the debugging loop. From here: read the [full review](/articles/latenode-review) for our verdict and where the platform is strong or weak, check the [pricing guide](/articles/latenode-pricing) to understand the CPU-second meter before you scale, and see the [AI playbook](/articles/latenode-ai-playbook) for deeper patterns with the 1,200+ built-in models. Start on the free plan, build the lead classifier above first — it's the fastest way to feel what makes Latenode different — and add the code and browser nodes once the basics click. ## References [1] Latenode — official pricing (CPU-seconds model) — https://latenode.com/pricing-plans (2026-07) [2] Latenode — features, 1,200+ AI models, JS/NPM — https://latenode.com/ (2026-07) [3] Latenode — Capterra reviews (4.9/5, 68) — https://www.capterra.com/p/10016543/Latenode/reviews/ (2026-07) [4] Latenode — GetApp reviews (4.9/5, 68) — https://www.getapp.com/development-tools-software/a/latenode/reviews/ (2026-07) [5] Latenode — Product Hunt community (4.9/5, 30) — https://www.producthunt.com/products/latenode/reviews (2026-07)