DEV Community: Emiliano Allende

Cost-Effective LLM Integration: Enforcing Strict JSON Schemas and Reducing Token Costs

Emiliano Allende — Thu, 12 Nov 2026 09:00:00 +0000

How to eliminate LLM parsing errors in production frontends, optimize system prompts, and keep AI generation costs around $0.05 or less per execution.

Integrating Large Language Models (LLMs) into production applications often introduces unpredictable behaviors: hallucinations, malformed text responses, and unexpected API rate limits. When an AI agent powers a user-facing interface (such as a React CRM dashboard previewing dynamic email drafts), a single broken markdown block or missing bracket can crash the entire frontend rendering pipeline.

This guide explores (from personal experience) how to build a resilient, cost-effective LLM integration layer using OpenRouter, Claude, and structured validation patterns that guarantee reliable outputs while keeping operational costs minimal.

1. The Core Problem: Unpredictable LLM Outputs

Standard LLM completions return unstructured natural language or even code fragments and unknown symbols. In automated pipelines, relying on regular expressions or loose string parsing to extract JSON payloads from a model's response is fragile.

To make LLM outputs safe for automated consumption, systems require two non-negotiable guarantees:

Guaranteed Structural Compliance: The model must output strictly parsed JSON matching a predefined schema. The architectural goal is to predefine the structured response so the client receives exactly what it wants.
Predictable Cost Control: Token consumption must be tightly managed through prompt engineering and cost-effective model routing. Paradoxically, efficiency means designing systems where the AI performs the minimum required computation—achieved by preparing comprehensive templates that provide the model with everything it needs to simply populate the final payload.

2. Enforcing Strict JSON Outputs via System Prompts

Instead of leaving output formatting to chance, the orchestration layer enforces strict boundaries directly in the system prompt configuration:

Explicit Schema Definition: The prompt explicitly defines the required JSON keys (such as subject, body, and corresponding nested fields), instructing the model to omit conversational filler, markdown code fences, and explanatory text.
Defensive Parsing: Downstream handlers validate the incoming response against strict DTO models before passing data to the UI state. If validation fails, the pipeline safely catches the exception instead of propagating bad data.

3. Optimizing Costs via OpenRouter and Model Selection

Running heavy frontier models for routine generation tasks quickly inflates operational budgets. Cost efficiency is achieved through targeted optimization:

Strategic Model Routing: Utilizing cost-effective, high-intelligence models via OpenRouter (such as routing between Claude Sonnet and Haiku variants depending on task complexity) reduces overhead drastically.
Optimized Token Budgets: Tuning system prompts to be concise reduces input token bloat, successfully bringing generation costs down to ~$0.04 - $0.06 per execution while significantly reducing generation latency.

Core Principles

Never trust raw LLM output: Always enforce strict schema validation before passing AI-generated payloads to frontend components.
Prompt engineering is architecture: Clear system constraints save compute cycles, reduce retries, and protect downstream systems from malformed data.
Smart routing preserves margins: Leveraging multi-model gateways like OpenRouter allows high-performance AI integration without breaking unit economics.

Building a Production-Ready Backend: From Modular Workflows to FastAPI, Clean Architecture, and CQRS

Emiliano Allende — Wed, 11 Nov 2026 20:49:03 +0000

How an evolutionary architectural approach—moving from decoupled low-code workflows to a robust Python backend—ensures long-term scalability and maintainability.

As growing applications scale, combining routing logic, database queries, and business rules inside a single monolithic file or massive workflow becomes unsustainable. Scaling out requires a deliberate architectural shift: separating concerns so that systems remain maintainable, testable, and ready for future technology transitions.

This article explores how to design a robust backend using FastAPI, Clean Architecture, and CQRS, leveraging Supabase (PostgreSQL) and drawing from lessons learned in modular automation design.

1. The Evolutionary Path: Why Modularity Matters

Before scaling into a heavy backend, systems often start as modular, decoupled blocks (such as independent automation flows handling specific tasks). This approach relies on three foundational pillars:

Scalability & Separation of Concerns: Splitting functionality ensures that no single execution handler becomes a massive bottleneck consuming unnecessary resources. Each component handles a single, well-defined responsibility.
Maintainability: When an issue arises, isolated modules make it straightforward to trace the exact source of failure.
Frictionless Technology Transition: When migrating core logic from low-code tools to a native code stack like Python (FastAPI), having a pre-existing modular structure makes translating functions clean, incremental, and highly systematic.

2. The Layered Architecture: Inward Dependencies

Following the core principle of Clean Architecture, dependencies must always point inward. The business logic remains completely agnostic of the framework (FastAPI) or the database driver (Supabase/PostgreSQL).

A clean directory structure enforces this boundary:

app/
├── api/                   # Frameworks & Drivers (FastAPI routers & middlewares)
├── application/           # Use cases / Application orchestration (CQRS Commands & Queries)
├── domain/                # Enterprise & Business Rules (Pure core, ports, value objects)
├── infrastructure/        # External adapters (Supabase, Brevo, OpenRouter integrations)
├── agents/                # Structured LLM orchestration agents
└── shared/                # Cross-cutting concerns (Result types, logging, config)

Strict Data Validation with Pydantic

To prevent silent data coercion and guarantee type safety across boundaries:

Strict Frontiers: API request/response schemas inherit from BaseModel configured with model_config = ConfigDict(strict=True) (and extra="forbid" on critical payloads) to reject unexpected properties or invalid types.
DTO Separation: HTTP request/response models reside in api/{module}/schemas.py, while Application DTOs handle data transfer between handlers and the domain, decoupling external JSON contracts from internal logic.
Zero-Any Policy: The codebase enforces strict typing (supported by mypy --strict), eliminating untyped dictionaries in favor of explicitly bounded structures.

3. Implementing CQRS and Decoupling the Database

Separating read operations (Queries) from state mutations (Commands) keeps the application lightweight, testable, and maintainable.

A. Dependency Inversion via Domain Ports (`domain/ports`)

To prevent domain logic from coupling directly to Supabase client libraries, the system defines abstract interfaces using Python's typing.Protocol:

class ClientPort(Protocol):
    async def get_by_id(self, client_id: str) -> Client | None: ...
    async def save(self, client: Client) -> None: ...
    async def list_active(self) -> list[Client]: ...

Building a Resilient B2B Email Marketing CRM Using n8n, LangChain, and OpenRouter

Emiliano Allende — Wed, 11 Nov 2026 19:04:32 +0000

How to split AI content generation from transactional mailing to prevent spam, ensure strict JSON outputs, and keep API costs low.

When building B2B outreach automation, combining AI generation and email dispatch into a single linear workflow is a recipe for disaster. If the AI you are using hallucinates, outputs malformed text, or triggers a rate limit, the entire execution fails, or even worse, sends an incorrect email to a client.

This guide focuses on how to solve this by designing a Two-Step architecture using n8n, LangChain, and OpenRouter (Claude), integrated with a clean database layer.

The Core Challenge

Standard email automation tools lack intelligent contextual personalization, while raw LLM implementations are unpredictable. For a modern B2B public sector CRM, the architecture required a system that could:

Extract organization metadata and generate hyper-personalized email drafts using advanced LLMs.
Force the LLM to output strict JSON structures so the frontend React interface can safely preview and edit the draft.
Enforce strict business logic (anti-spam cooldowns) before dispatching via an email provider API.

The Solution: a Two-Step Workflow Architecture

Instead of a monolithic flow, the logic was split into two decoupled n8n workflows: MailWriter and Mailer.

Step 1: The MailWriter Workflow (AI Generation)

The first workflow receives the organization's payload from the frontend, queries contextual data, and passes it to an AI agent node.

LLM Orchestration: LangChain was utilized inside n8n connected to OpenRouter running Claude, optimizing prompt engineering to act as an expert B2B copywriter.
Strict JSON Output: To prevent downstream parsing errors in the React frontend, the system prompt explicitly enforces a JSON schema containing subject and body.
Cost Efficiency: By tuning system prompts and leveraging cost-effective routing via OpenRouter, leading to a significant reduction in generation costs to ~$0.04-0.06 per email.

Step 2: The Mailer Workflow (Business Logic & Dispatch)

Once the user reviews and approves the draft in the CRM interface, the second workflow takes over.

Anti-Spam Date Checker: Before any HTTP request is fired, a logic node checks the last contact timestamp stored in the database. If fewer than 15 days have passed since the previous outreach, the workflow safely halts, preventing over-communication.
Transactional Dispatch: If conditions are met, it triggers the Brevo API to dispatch the email.
State Synchronization: Immediately after a successful send, it updates the database record with the new timestamp, maintaining seamless inter-system traceability.

Key Takeaways

Decoupling is key: Separating generation from dispatch gives humans a chance to review AI outputs safely.
Guardrails save operations: Implementing strict date-check logic protects client relationships from accidental spamming.
Modular automation: Using n8n combined with structured API nodes bridges the gap between no-code speed and full-stack reliability.