One spectrum, not two camps

"Code vs no-code" is a false binary; it's a spectrum of how much you build vs. configure:

• No-code (Zapier, Make) — visual triggers and actions, hosted, huge app-connector libraries. You configure; you don't deploy anything. Fastest to a working automation.
• Low-code (n8n) — visual like Zapier but self-hostable, with code nodes, real branching/loops, and more control. The middle ground (and where your VPS-hosted automation lives).
• Code (LangChain/LlamaIndex/custom) — full control, any logic, testable, versioned. Most effort, most power, most maintenance.

The skill isn't picking a side — it's matching the point on the spectrum to the specific workflow in front of you. The same client often has some flows best in Zapier and others that must be code.

The decision axes

Score the workflow on each axis; the answers point to a tier.

Axis	Leans no-code / low-code	Leans code
Complexity	linear triggers, a few steps, standard connectors	complex branching, custom logic, novel integrations
Reliability needs	best-effort, human catches errors	high-stakes, needs tests, retries, guarantees
Cost at scale	low volume (per-task pricing is fine)	high volume (per-task fees explode; code is cheaper/task)
Security / data control	non-sensitive data, vendor cloud is fine	sensitive/regulated data, must self-host or stay in your VPC
Maintainability	small team, non-engineers must edit it	engineering team, needs version control, CI, review
Speed to ship	need it working this week	can invest in a durable build
Vendor lock-in	acceptable, tool is core to the workflow	must stay portable across providers

No single axis decides it — you weigh them. A high-volume, sensitive-data, high-reliability flow screams code even if it's simple; a one-off internal alert that runs 10x/day is no-code even if it touches an LLM.

Where each tier wins

No-code (Zapier/Make) wins for: connecting SaaS apps you don't control, non-engineers owning the flow, getting a proof-of-concept live today, low volume. It loses when logic gets complex, volume makes per-task pricing hurt, or you need tests and data control.

Low-code (n8n) wins for: the same visual speed but self-hosted (data stays on your infra), real branching/loops, code nodes for the tricky 10%, and no per-task SaaS fees. It's the pragmatic default for a solo consultant or small team who wants control without a full codebase — which is exactly why it's a common backbone for AI automation.

Code (LangChain/custom) wins for: complex agentic logic (everything in Tracks 1–7), high reliability with a test suite and evals (Track 5), high volume where compute-per-task beats per-task fees, sensitive data under full control, and anything that must be versioned, reviewed, and CI'd.

The hybrid that often wins

The best answer is frequently not one tier — it's no-code for the glue and code for the hard part. Let a no-code/low-code tool own the triggers, the SaaS connectors, and the orchestration, and hand off the genuinely hard AI logic to a small code service it calls over a webhook:

# A tiny code service that n8n / Make / Zapier calls via an HTTP node for the part they do poorly.
from fastapi import FastAPI                     # a minimal web API (from the Python track)
app = FastAPI()

@app.post("/classify")                           # the no-code tool POSTs here at the right step
def classify(payload: dict):
    # The hard AI logic lives in CODE (testable, versioned, evaluable) — not in a brittle no-code prompt box:
    result = my_rag_agent(payload["text"])       # your Track 1-7 pipeline: RAG, agent, evals, etc.
    return {"category": result.category, "confidence": result.confidence}   # n8n reads this and continues the flow

The no-code side keeps its strengths (connectors, visual flow, non-engineer editing); the code side owns what it does best (complex logic, tests, evals, data control). This seam — a webhook to a small service — is the single most useful pattern for shipping AI automation pragmatically, and it lets you start no-code and migrate the hard 10% to code without a rewrite.

Migration signals

Start simple; know when to graduate a flow up the spectrum. Move toward code when you see:

• Prompt logic sprawling inside no-code text boxes (untestable, unversioned).
• Per-task bills climbing as volume grows.
• Reliability incidents you can't debug or add retries/tests for.
• Data/compliance pressure to keep processing on your own infra.
• The tool fighting you — stacking hacks to force logic it wasn't built for.

Conversely, don't graduate a flow that's working fine in no-code just because code feels "more serious" — that's the over-engineering trap.

Pitfalls

• Tool-first thinking. Choosing your favorite tool then bending the problem to it. Score the workflow, then pick.
• Ignoring cost-at-scale. Per-task no-code pricing is cheap at low volume and brutal at high volume — model it.
• Ignoring data control. Sensitive/regulated data often rules out vendor-cloud no-code regardless of convenience.
• All-or-nothing. Missing the hybrid seam and building the whole thing in one tier when a webhook split is better.
• Never migrating. Letting a flow that's outgrown no-code limp along instead of extracting the hard part to code.

Recap

• No-code, low-code, and code form one spectrum; the skill is matching the tier to the specific workflow.
• Decide on the axes: complexity, reliability, cost at scale, security/data control, maintainability, speed, lock-in — weighed together, not any one alone.
• No-code wins for fast SaaS glue and non-engineers; low-code (n8n) for self-hosted control with visual speed; code for complex, high-reliability, high-volume, sensitive, versioned systems.
• The hybrid — no-code glue calling a small code service over a webhook — often wins, and enables starting simple then migrating the hard 10%.
• Avoid both over-engineering (forcing code) and hitting the ceiling (forcing no-code); calling it correctly is the consulting value.
• Worked examples map to the exercises: axis scoring (Ex 1), the migration seam (Ex 2), a hybrid design (Ex 3), and tier selection across scenarios (Ex 4).

Typeform → [enrich] → HTTP POST /score-lead  (your code: RAG + agent + eval)  → [HubSpot write]

from fastapi import FastAPI
app = FastAPI()

@app.post("/score-lead")
def score_lead(payload: dict):          # n8n/Make POSTs {name, company, message, ...}
    ev = rag_score(payload)             # private-KB RAG + agent logic (Tracks 1-7), tested + eval-gated
    return {"score": ev.score, "priority": ev.priority, "rationale": ev.rationale}