Lesson 159 — Intermediate

Visual AI Workflows with n8n-style Automation

Is lesson ka mental model: Trigger → steps → gates → actions — agents branches runtime mein discover karte hain, workflows unhe pehle se draw kar deti hain. Is lesson mein tum ek deterministic visual AI workflow design karoge: triggers aur nodes kaise bante hain, secrets kahan rakhte hain, kab fixed DAG agent se behtar hai, human gate kahan mandatory hai, aur wo signals kya hain jo kehte hain — graph ab code mein shift karna hai.

Workflow kyun — known path ko pehle se draw karo

Fixed graph ka asli faayda auditable hona hai: har branch, har error route likha hua hai, ek run ek hi jagah fail hota hai, aur cost per run predictable. Agent ka ulta hai — raasta log mein dhundhna padta hai. Isliye workflow default hai, agent ek choice — dono ka hybrid bhi chalta hai.

Nodes, triggers aur credentials — canvas ka asli roop

# visual flow ka export — canvas ka asli roop JSON hi hai
name: nightly-invoice-triage
trigger:
  type: schedule            # event | webhook | schedule
  cron: "0 2 * * *"         # roz raat 2 baje
nodes:
  - id: fetch
    type: http
    credential: inbox_api    # secret yahin judta hai, node ke andar nahi
  - id: classify
    type: ai
    task: invoice ya other   # chhota model, structured label out
  - id: extract
    type: ai
    schema: { vendor: str, amount: number, date: str }
  - id: gate
    type: approval
    when: amount > 20000     # yahan workflow jaan-boojh kar rukta hai
  - id: notify
    type: email
    after: gate.approved
edges: [fetch -> classify -> extract -> gate -> notify]

• Triggers teen: event (kuch hua — naya row, naya message), webhook (dusri system ne bheja), schedule (time pe). Sahi trigger hi SLA ka hissa hai.
• Node types: HTTP (API call), code (chhota transform), AI (classify/extract/generate), logic (filter/merge/split), action (email/sheet/DB) — ek node, ek kaam.
• Credentials: platform ka credential store alag hota hai — canvas pe key/password kabhi mat likho. Export/screenshots share karne se secret nahi jaana chahiye, par rule pehle banao.
• Data mapping: har node ka output agle ka input — keys ka schema pehle tay karo, warna ek rename se poora graph toot jaata hai.

Structured vs agentic — reliability aur cost ka faisla

Decision rule ek hi hai: path pehle se likh sakte ho toh fixed DAG; har baar rasta alag banana hai toh agent. Fixed graph ka faayda — targeted retry, testable behavior (known input → known path), predictable cost. Agent ka kharcha dono taraf zyada — har turn pe model call, context bhi badhta hai — aur failure ka raasta log mein dhundhna padta hai.

kaunsa frame? (decision table)

path known + high volume + compliance steps  -> fixed DAG
input ka shape unknown + judgement chahiye   -> agent

hybrid: graph ka ek node andar se agent chalaye
        (known skeleton, open joint) — production ka common answer

faayde (DAG)              kharche (agent)
targeted retry            har turn = model call
path testable hai         behavior probabilistic
cost per run fixed        context badhta hai (cost bhi)

• Workflow pehle chuno: daily batch, fixed integrations, mandatory approval wali steps, high volume — jagah jagah se reliability aati hai.
• Agent tab: input ka shape unknown, decision judgement maangta hai, volume kam jahan exploration chalti hai.
• Hybrid pattern: graph ka ek node andar mein agent chala sakta hai — skeleton fixed, joint open. Yehi aksar sahi architecture nikalta hai.
• Volume multiplier: fixed graph sirf zaroori nodes chalata hai; agent model call har turn karta hai — traffic badhi toh farq chhat jaata hai.

Human gates, idempotency aur retries — automation ko dheere rokna

{
  "run":             "2026-10-19T02:00:00",
  "step":            "notify",
  "invoice":         "INV-88213",
  "idempotency_key": "INV-88213:notify",
  "status":           "retry",
  "attempts":         2,
  "note":             "same key -> downstream duplicate email nahi bhejega"
}

retry rule: transient (timeout, 429) -> exponential backoff, max attempts cap
            permanent (400 validation) -> retry NAHI, error route pe bhejo

• Approval gate kahan: paisa, bahar ko email, publish, delete — jab galti ka cost zyada ho. Gate ka matlab hai workflow jaan-boojh kar dheere chalta hai.
• Idempotency: har side-effect step ka ek key (resource + step). Dobara run ho toh downstream pehle wala result maan le — duplicate email ya duplicate payment nahi.
• Retries: transient failure pe backoff aur cap; permanent failure pe bilkul nahi — har node ka onError route (log/alert/fallback) pehle se likha ho.
• State machine: pending → approved | rejected → next. Gate ke baad kahan continue hota hai wo canvas pe draw karo — half-approved state sabse ganda bug hai.

Run karna, monitor karna aur code mein graduate hona

execution history ka record (style)
time      node      status  ms   note
02:00:01  fetch     ok      810  12 rows
02:00:02  classify  ok      430  12/12 labelled
02:00:03  extract   error   90   schema mismatch: amount str
02:00:03  route     -> error branch, retry 1 scheduled

signals:
  ek hi node bar bar fail      -> wahi fix karo, graph nahi
  manual step roz repeat       -> human gate galat jagah hai ya requirement badli
  run time > budget            -> steps kam karo ya async karo
  code nodes ghuste ja rahe    -> graph ab code maang raha hai

• Execution history hi observability hai: har run ka input, node-wise status, time — ye L10 wale monitoring ka chhota cousin hai, par pattern wahi hai.
• Graduate to code ke signals: logic bar-bar code node mein chhup raha ho, tests/CI/versioning chahiye, ya graph ke copies-forks fail ho rahe hain.
• Migration ka raasta: graph ko spec samjho (nodes + edges + retries) aur wahi DAG FastAPI/Docker service mein likho — logic alag nahi, jagah badalti hai.
• Division of labour: canvas mein glue, integrations, quick changes; code mein core logic, tests aur SLA wali serving.

Exercise

Common mistakes

• Har problem ko agent sochna: Known path pe agent chunna = zyada cost, probabilistic behavior aur mushkil debugging. Fix: pehle DAG banao, sirf genuinely open decision wali node kholo.
• Canvas pe secrets likh dena: Export, screenshot aur shared flow sab leak ho sakte hain. Fix: platform ka credential store, code/env kabhi canvas pe nahi — aur rotation bhi wahi se.
• Retries bina idempotency ke: Timeout pe dobara chalaya toh do emails ya do payments — automation ne khud nuksan kar diya. Fix: har side-effect step ka key pehle se, phir retry.
• Paisa/irreversible wala step auto chalana: Bina approval ke refund ya publish ho gaya toh rollback mushkil. Fix: human gate mandatory jahan galti ka cost zyada ho, aur states pehle define.

route: [form, manager, hr]              # fixed path — workflow
gate:  { when: amount > 20000, needs: finance_approval }
retry: { on: [timeout, 429], max: 3, backoff: exponential }
idempotency_key: employee_id + step      # duplicate reimbursement nahi