How I Built 9 Claude AI Features into a Production SaaS

Engineering Production-Ready AI Features: A Multi-Tenant SaaS Architecture Guide

Current Situation Analysis

Integrating generative AI into a multi-tenant SaaS product introduces a triad of engineering challenges: cost volatility, hallucination risks, and data compliance. Many development teams treat AI integration as a simple API wrapper, assuming that model capability alone guarantees value. This approach fails in production because it ignores unit economics, tenant isolation, and the deterministic nature of enterprise data.

The industry pain point is not model availability; it is safe, scalable orchestration. Teams often deploy expensive models for tasks that require simple pattern matching, leading to margin erosion. Others expose raw personally identifiable information (PII) to third-party APIs, creating GDPR/CCPA liabilities. Furthermore, natural language interfaces to databases are frequently implemented without sufficient guardrails, resulting in SQL injection vulnerabilities or cross-tenant data leaks.

Data from production deployments reveals that capability matching is more critical than raw model intelligence. For structured tasks like schema mapping, data summarization, and SQL generation, smaller models like claude-haiku-4-5 deliver sufficient accuracy while maintaining sub-2-second latency and significantly lower token costs compared to larger variants. This enables AI features to be offered on free or low-tier plans without destroying unit economics. However, this efficiency only holds when the architecture enforces strict boundaries: credit-based consumption, PII sanitization, and deterministic fallbacks.

WOW Moment: Key Findings

The most impactful insight from production AI engineering is that model selection should be driven by task constraints, not capability ceilings. Using a high-reasoning model for structured output generation increases cost and latency without improving reliability. Conversely, a smaller model, when paired with rigorous validation and fallback mechanisms, can handle the majority of SaaS AI workloads safely.

The following comparison illustrates the trade-offs observed in a production environment handling citizen management data:

Feature Type	Recommended Model	Latency Target	Cost Efficiency	Risk Mitigation Strategy
Schema Mapping	claude-haiku-4-5	< 2s	High	JSON schema validation + Fuzzy match fallback
NL-to-SQL Filter	claude-haiku-4-5	< 2s	High	Allowlist columns + Regex blocklist + Tenant injection
Data Summarization	claude-haiku-4-5	< 2s	High	Aggregated stats only; raw PII scrubbed
Complex Reasoning	claude-sonnet-4-5	> 4s	Medium	Human-in-the-loop approval; Credit cap
Anomaly Detection	Deterministic Code	< 50ms	N/A	Python/TS logic; AI used only for explanation

Why this matters: This matrix enables engineering teams to design AI features that are financially sustainable and technically robust. By routing tasks to the appropriate model and enforcing safety layers, teams can ship AI functionality that enhances user experience without introducing operational debt or compliance risks.

Core Solution

Building production-ready AI features requires a layered architecture that treats the LLM as an advisory service rather than an execution engine. The following implementation details outline a TypeScript-based approach, emphasizing safety, cost control, and reliability.

1. The Credit Gateway Pattern

Every AI invocation must be gated by a credit system to enforce tenant quotas and manage costs. Credits are deducted before the API call, with refunds issued on failure to prevent user frustration.

import { PrismaClient } from '@prisma/client';
import { PaymentRequiredError } from './errors';

const prisma = new PrismaClient();

export async function consumeTenantCredits(
  tenantId: string,
  cost: number
): Promise<void> {
  const tenant = await prisma.tenant.findUnique({
    where: { id: tenantId },
    select: { aiCredits: true },
  });

  if (!tenant || tenant.aiCredits < cost) {
    throw new PaymentRequiredError(
      'Insufficient AI credits. Please upgrade your plan.'
    );
  }

  await prisma.tenant.update({
    where: { id: tenantId },
    data: { aiCredits: { decrement: cost } },
  });
}

export async function refundCredits(
  tenantId: string,
  cost: number
): Promise<void> {
  await prisma.tenant.update({
    where: { id: tenantId },
    data: { aiCredits: { increment: cost } },
  });
}

Rationale: Pre-deduction ensures that tenants cannot exhaust credits on failed requests. The PaymentRequiredError maps to HTTP 402, triggering a clear upgrade prompt in the frontend. This pattern aligns AI usage with business metrics and prevents abuse.

2. PII Sanitization Pipeline

Sending raw PII to external APIs is a compliance violation. A sanitization layer must strip sensitive fields before prompt construction.

const SENSITIVE_FIELDS = ['tcNo', 'ssn', 'email', 'phone'];

export function sanitizePayload<T extends Record<string, any>>(
  payload: T
): Partial<T> {
  const sanitized: Partial<T> = {};
  for (const key in payload) {
    if (!SENSITIVE_FIELDS.includes(key)) {
      sanitized[key] = payload[key];
    }
  }
  return sanitized;
}

// Usage in duplicate merge feature
const safeRecordA = sanitizePayload(recordA);
const safeRecordB = sanitizePayload(recordB);

const prompt = `
  Compare these records and suggest a merge.
  Record A: ${JSON.stringify(safeRecordA)}
  Record B: ${JSON.stringify(safeRecordB)}
  Return JSON with "keepId" and "mergedData".
`;

Rationale: Field-level scrubbing ensures that regulated data never leaves the tenant's environment. The AI operates on safe subsets, reducing liability while maintaining functionality.

3. NL-to-SQL with Defense-in-Depth

Natural language to SQL conversion requires multiple validation layers to prevent injection and ensure tenant isolation.

const ALLOWED_COLUMNS = new Set([
  'name', 'dob', 'gender', 'city', 'district', 'created_at',
]);

const BLOCKED_PATTERNS = [
  'drop', 'delete', 'update', 'insert', 'alter', 'exec',
  '--', ';', 'union', 'sleep', 'pg_',
];

export function validateSqlClause(
  clause: string,
  tenantId: string
): string {
  const lower = clause.toLowerCase().trim();

  // Structure check
  if (!lower.startsWith('where')) {
    throw new Error('Invalid SQL clause: must start with WHERE');
  }

  // Blocklist check
  for (const pattern of BLOCKED_PATTERNS) {
    if (lower.includes(pattern)) {
      throw new Error(`Blocked SQL pattern detected: ${pattern}`);
    }
  }

  // Allowlist check
  const columnMatches = lower.match(/[a-z_]+/g) || [];
  for (const col of columnMatches) {
    if (
      !ALLOWED_COLUMNS.has(col) &&
      col !== 'where' &&
      col !== 'and' &&
      col !== 'or' &&
      col !== 'is' &&
      col !== 'null'
    ) {
      throw new Error(`Column not allowed: ${col}`);
    }
  }

  // Tenant isolation injection
  if (!lower.includes(`tenant_id = '${tenantId}'`)) {
    return `${clause} AND tenant_id = '${tenantId}'`;
  }

  return clause;
}

Rationale: Defense-in-depth ensures that even if the LLM generates malicious or erroneous SQL, the validation layer blocks execution. Tenant ID injection guarantees data isolation. This approach allows safe NL search without exposing the database schema.

4. Deterministic Fallback Strategy

AI should never be the sole source of truth for critical operations. Fallback mechanisms ensure reliability when the model fails or returns invalid output.

import { similarity } from 'fastest-levenshtein';

export async function mapCsvColumns(
  headers: string[],
  schema: string[]
): Promise<Record<string, string | null>> {
  try {
    const response = await callClaude({
      prompt: `Map headers to schema. Return JSON only.`,
      schema,
      headers,
    });
    return JSON.parse(response);
  } catch (error) {
    // Fallback to fuzzy matching
    const mapping: Record<string, string | null> = {};
    for (const field of schema) {
      let bestMatch: string | null = null;
      let bestScore = 0;
      for (const header of headers) {
        const score = similarity(field, header);
        if (score > bestScore) {
          bestScore = score;
          bestMatch = header;
        }
      }
      mapping[field] = bestScore > 0.7 ? bestMatch : null;
    }
    return mapping;
  }
}

Rationale: The fallback ensures that features remain functional even during API outages or model errors. Fuzzy matching provides a reasonable default for schema mapping, maintaining user experience without AI dependency.

Pitfall Guide

Production AI engineering is fraught with subtle failure modes. The following pitfalls highlight common mistakes and their remedies based on real-world deployments.

Pitfall Name	Explanation	Fix
PII Leakage	Sending raw sensitive data to the LLM violates GDPR and exposes data to third-party logs.	Implement a strict sanitization layer that strips PII before prompt construction. Use field allowlists.
SQL Injection via Prompt	LLMs can generate malicious SQL if not constrained, leading to data breaches or corruption.	Use defense-in-depth: allowlist columns, blocklist dangerous keywords, inject tenant filters, and enforce DB user permissions.
Cost Blindness	Using high-capability models for simple tasks inflates costs without improving accuracy.	Profile tasks and route them to the smallest sufficient model. Implement credit caps and monitoring.
Silent JSON Failures	LLMs may return explanatory text instead of structured JSON, breaking downstream parsing.	Enforce strict schema validation. Implement fallback mechanisms for parsing errors.
Auto-Applying AI Suggestions	Automatically executing AI-generated merges or actions can lead to data corruption.	Require human-in-the-loop approval for all write operations. Display AI output as suggestions only.
Tenant Cross-Contamination	Failing to isolate tenant data in prompts or queries can leak information across tenants.	Hardcode tenant IDs in prompts and SQL queries. Validate tenant isolation at the database level.
Timeout Neglect	LLM calls can hang indefinitely, causing resource exhaustion and poor UX.	Set strict timeouts (e.g., 20s) and implement retry logic with exponential backoff. Refund credits on timeout.

Production Bundle

Action Checklist

• Audit PII Exposure: Review all prompts and ensure no sensitive data is sent to the LLM. Implement sanitization.
• Implement Credit Gateway: Add credit deduction and refund logic to all AI endpoints. Map errors to HTTP 402.
• Define Validation Rules: Create allowlists, blocklists, and schema validators for all AI-generated output.
• Add Fallback Mechanisms: Ensure features have deterministic fallbacks for AI failures or invalid output.
• Enforce Tenant Isolation: Verify that all queries and prompts include tenant filtering. Test for cross-tenant leaks.
• Set Timeouts and Retries: Configure strict timeouts for LLM calls. Implement retry logic with credit refunds.
• Review Human-in-the-Loop: Ensure all write operations require user confirmation. Display AI output as suggestions.
• Monitor Costs and Latency: Track token usage, latency, and error rates. Optimize model selection based on metrics.

Decision Matrix

Scenario	Recommended Approach	Why	Cost Impact
High-volume schema mapping	claude-haiku-4-5 + Fallback	Low latency, sufficient accuracy, cost-effective	Low
Complex data reasoning	claude-sonnet-4-5 + Human Approval	Higher capability needed for nuanced decisions	Medium
PII-heavy operations	Deterministic Rules Only	Compliance risk outweighs AI benefits	N/A
NL-to-SQL search	claude-haiku-4-5 + Strict Validation	Safe, fast, and accurate with guardrails	Low
Data summarization	claude-haiku-4-5 + Aggregated Stats	No PII exposure, concise output	Low

Configuration Template

// ai.config.ts
export const AI_CONFIG = {
  model: 'claude-haiku-4-5',
  maxTokens: 300,
  timeout: 20000, // 20 seconds
  creditsPerCall: 1,
  validation: {
    allowedColumns: ['name', 'dob', 'gender', 'city', 'district'],
    blockedPatterns: ['drop', 'delete', 'update', 'insert'],
    tenantField: 'tenant_id',
  },
  fallback: {
    enabled: true,
    strategy: 'fuzzy_match',
  },
};

Quick Start Guide

1. Install Dependencies: Add @anthropic-ai/sdk and zod for schema validation.
2. Setup Environment: Configure API keys and tenant credit limits in your environment variables.
3. Create Gateway: Implement the credit consumption and refund logic as middleware.
4. Define Schemas: Use Zod to define expected output structures for AI responses.
5. Test with Mocks: Validate fallback mechanisms and error handling using mock AI responses.

By adhering to these principles, engineering teams can build AI features that are safe, cost-effective, and reliable. The key is to treat AI as a regulated subsystem, enforcing strict boundaries and prioritizing user trust over capability.