
In 2026, every SaaS roadmap has an AI column. The first item is usually easy: "summarise this record" or "draft a reply." Every low-code platform has a block for that now, and so does every prompt-to-app builder.
The second and third items are where teams get stuck. "Answer questions across this customer's documents." "Let the assistant update the CRM and send the follow-up." These are not single model calls. They are small distributed systems with security, cost and correctness requirements, and they are where visual abstractions start leaking.
This post breaks down the specific engineering concerns, with a couple of small snippets, as a technical companion to TechCirkle's guide on custom development vs low code for SaaS founders.
Concern 1: Retrieval you can actually reason about
Production retrieval-augmented generation (RAG) needs control over several stages:
-
Chunking — splitting by semantic section rather than fixed character counts, which matters a lot for contracts, tickets and code.
-
Embedding and storage — choosing the model, dimensions and index type.
-
Tenant filtering — applied before similarity ranking, never after.
-
Re-ranking and citations — so users can verify where an answer came from.
Most low-code AI blocks collapse all four into a single "knowledge base" toggle. That is fine for a demo and a problem the first time an enterprise security team asks how you guarantee one customer's documents never surface in another's answer.
Concern 2: Agents need permissions, not just tools
An agent that can act is a privileged user. It needs the same authorisation checks as a human, plus approval gates for anything irreversible. A minimal pattern looks like this:
const tools = {
updateDealStage: {
description: "Move a CRM deal to a new stage",
requiresApproval: false,
run: async (ctx, { dealId, stage }) => {
await authorize(ctx.user, "deal:update", dealId); // same check as the UI
return crm.updateStage(ctx.tenantId, dealId, stage);
},
},
sendCustomerEmail: {
description: "Send an email to a customer contact",
requiresApproval: true, // human-in-the-loop for irreversible actions
run: async (ctx, args) => {
await authorize(ctx.user, "email:send", args.contactId);
return mailer.send(ctx.tenantId, args);
},
},
};
async function executeToolCall(ctx, name, args) {
const tool = tools[name];
await audit.log(ctx, name, args); // every action is traceable
if (tool.requiresApproval) return approvals.enqueue(ctx, name, args);
return tool.run(ctx, args);
}
The important lines are the boring ones: reusing the same authorize function as the human UI, writing an audit record for every call, and routing risky actions to a queue. Visual agent builders frequently let the model call integrations with the workspace's credentials and no per-user check, which quietly turns every user into an admin.
Concern 3: Model routing and cost per tenant
Token spend is a variable cost that scales with your most enthusiastic customers. In code you can:
-
route classification and extraction to small, cheap models, reserving larger ones for reasoning;
-
cache embeddings and frequent completions;
-
meter tokens per tenant and enforce plan limits;
-
swap providers without rewriting product logic.
Inside platform credits, most of that is invisible. One heavy customer can consume margin you did not know you had.

Concern 4: Evaluation is part of the product
Prompts are code. They regress. A production AI feature needs a fixed set of test inputs, expected behaviours and a way to score changes before they ship. That means versioned prompts in your repository, an evaluation job in CI and dashboards for live quality signals. Low-code environments rarely give you a place to put any of this.
What about AI app builders?
Prompt-to-app tools are a genuinely new option and they are great for exploring an idea. Before trusting one in production, run a hardening pass:
-
Review database access rules; generated apps often default to permissive policies.
-
Search for secrets in client-side code.
-
Add a real tenancy model with database-enforced isolation.
-
Write tests for authorisation paths, not just happy paths.
-
Check where data and auth are actually hosted, and whether you can move them.
Often the right move is to keep the prototype as a living spec and rebuild the core cleanly, using AI coding assistants under senior review. In 2026 that rebuild is far cheaper than it used to be, which is exactly why the argument for staying on a fragile foundation has weakened.
The practical split
Keep internal tools and simple automations on low-code. Put the customer-facing core, tenancy, billing, API and anything AI-native in code you own. If you need a team that does that split routinely, TechCirkle offers LLM integration and AI development for SaaS products.
Frequently Asked Questions
Can low-code platforms run production RAG?
They can run basic retrieval, but they usually hide chunking, tenant filtering and ranking. That makes it hard to guarantee isolation or tune quality for B2B use.
What is the biggest risk with AI agents in SaaS?
Agents acting with broader permissions than the user who triggered them. Reuse your normal authorisation checks and require approval for irreversible actions.
How do I control LLM costs per customer?
Meter tokens per tenant, route simple tasks to cheaper models, cache where possible and tie usage to plan limits. This is much easier in a custom stack.
Are AI-generated apps secure by default?
Often not. Common issues include permissive data rules, exposed keys and missing authorisation checks. Always run a security and architecture review first.
Should prompts live in version control?
Yes. Treat prompts like code: version them, test them against a fixed evaluation set and review changes before release.