Writing from the studio.
Practical notes on AI automation — what works in production, what doesn’t, and how we think about the decisions in between.
How to Automate Decisions With LLMs Without Losing Control
Use LLMs to classify, route and approve safely: constrain outputs, treat confidence as a measured signal, and escalate low-confidence cases to a human.
Retry Policies for Flaky LLM API Calls That Won't Cascade
How to retry LLM API calls safely: backoff with jitter, retry budgets, circuit breakers, and idempotent jobs, with TypeScript code you can adapt.
LangChain vs Custom Code: When a Framework Is Worth It
Use LangChain or LlamaIndex to prototype and for genuinely graph-shaped agents. For fixed pipelines in production, plain code is usually easier to run and debug.
Running Multiple LLMs in Production: Beyond the Gateway
A gateway normalises requests, not operations. Here's what still breaks across providers: logs, cost tracking, schema drift, and failover that was never tested.
LLM Observability: Why Your Logs Aren't Enough
Standard application logs miss critical data for debugging AI features. Learn what to capture, when to use specialized tools, and how to start.
How to Manage LLM API Keys and Secrets in Production
Keep LLM API keys out of env files and images: use a secrets manager, per-service keys, IAM roles where possible, and overlap-based rotation with no downtime.
How to Keep Data Private When Using External LLM APIs
Send the model less data, strip identifiers before the call, and get retention terms in writing. A practical guide to LLM API privacy for engineering teams.
Human Oversight in AI Workflows Without the Bottleneck
Good human oversight of AI workflows means risk-tiered review queues, explicit escalation paths and corrections that feed back into your evals, not approval on every output.
How to Get Buy-In for Your First AI Automation Project
Pick a boring, reversible process, baseline it before you build, and promise less than you expect to deliver. That's how you win internal buy-in for AI.
Function Calling Isn't Enough: Building Reliable LLM Tool Use
Basic function calling breaks in production. Here's how we build schema validation, retries, and tool versioning into agents that call real APIs.
Do You Actually Need a Vector Database in 2026?
Most teams reach for Pinecone when pgvector would do. Here's how to pick between Postgres, Qdrant, Weaviate, and Pinecone based on real workloads.
How Do You Manage Long Context Windows in Production LLMs?
Summarization, RAG, and sliding windows solve different context problems — here's when to use each and where they fail in production.
How Our Web Design Pricing Actually Compares to Other Agencies
Local agencies typically split website builds and SEO/GEO into two invoices; we quote one number, US$4,950 (about A$7,100), with both included — here's where that sits against freelancers, boutique agencies, and retainer-model shops.
What Happens When Your AI Vendor Deprecates Your Model
Model deprecation is scheduled, not hypothetical — here's how to build AI integrations that survive it instead of breaking in production.
What a Website Actually Costs in Australia (and Why Cheap Offshore Isn't Cheaper)
A custom website in Australia runs $3,000–$25,000+; offshore template work looks cheaper upfront but the real cost shows up after launch, in edits you can't make and traffic you never get.
Local SEO vs. SEO vs. GEO: What's Actually Different
Local SEO, classic SEO, and GEO get lumped together constantly. Here's what each one actually optimizes for, and why the fix for one doesn't fix the others.
Build vs. Buy for AI Features: When Off-the-Shelf Wins
Don't default to custom AI builds. We share TelaLoom's framework for when existing SaaS tools solve 90% of the need faster and cheaper.
Three questions to ask before hiring an AI agency
Avoid unmaintainable AI prototypes. Ask these three questions to find an agency that delivers robust, cost-effective production systems.
Why 'It Looked Right When I Tried It' Isn't a Test
“It looked right when I tried it” isn't a test. Here's why a real eval set should gate every prompt or model change before it ships.
What Actually Happens in Week One With an AI Automation Partner
A concrete walkthrough of a discovery week: what gets mapped, what gets ruled out, and the deliverable you should walk away with.
Which AI Automations Pay Back in 90 Days (And Which Don't)
A pattern from our own products and client work: narrow, high-volume automations pay for themselves fast — ambitious “AI agent” builds usually don't.
Your AI Feature Launch Was The Cheap Part
Model deprecations, prompt drift, and pricing shifts mean AI features keep costing money after launch — most quotes never account for it.
Automate the Boring Step First, Not the Impressive One
Why the highest-friction, most repetitive task should be the first thing you automate, and how that sequencing decides whether the project gets funded again.
Prompt Versioning: The Boring Practice That Saves AI Projects
Untracked prompts cause silent quality regressions in production AI systems — here's the lightweight version-control discipline that prevents it.
Rate Limits, Retries, Timeouts: What Makes AI Actually Reliable
A better model doesn't fix a flaky AI integration. Backoff, idempotency, and graceful degradation do — here's how we build them.
What Breaks First When You Put an LLM in Production
Rate limits, silent format drift, and untested timeouts are what actually take down LLM pipelines — not the failure modes teams demo for.
Zapier vs Custom Code: A Real Decision Framework
Volume, error handling, and reasoning needs decide whether Zapier or n8n is enough — or whether you need custom code. Here's the framework.
Stop AI Project Blowouts: Scope Right from Day One
AI projects often derail after the demo. Learn how to scope with fixed evaluations, clear metrics, and bounded goals to ship production AI on time.
AI Agent or Automation? Choose Wisely for Production.
Most businesses asking for 'AI agents' actually need deterministic automation, which is cheaper, more reliable, and easier to debug for production systems.
Why Most AI Agent Projects Never Make It Past the Demo
The gap between an AI agent demo and a shipped product isn't the model — it's evals, failure handling, and the edge cases real users find in week one.
Fine-Tune or Prompt Better? A Decision Tree for 2026
Fine-tune when you have 1,000+ labelled examples and a bounded task. Otherwise, prompt engineering wins on cost and speed. Here's the real decision tree.
How Do You Handle Failures in an AI Pipeline Gracefully?
A production AI pipeline needs validation, retries, fallbacks, and escalation for every failure mode — not just a try/catch around the API call.
How to Set Up Your Own VPS Hosting (and Actually Secure It)
A plain-English, step-by-step walkthrough for setting up your first VPS: picking a provider, locking down SSH, a firewall, automatic updates, and getting a domain live with SSL.
How Do You Test an AI System Before It Goes to Production?
A practical eval stack for AI systems: unit evals, integration evals, and regression evals, and what “good enough” actually means before you ship.
The AI Stack We Actually Run in Production (2026)
No gateway zoo, no vector database by default. The unglamorous AI stack TelaLoom actually runs in production in 2026 — and when the heavier tools are worth adding.
What an SEO & GEO Audit Actually Finds
The recurring, fixable issues we find on almost every unaudited site: broken schema, missing llms.txt, robots.txt accidentally blocking AI crawlers, and thin metadata.
Why “SEO” Now Means Being Cited by ChatGPT Too
Generative engine optimization (GEO) is the practice of structuring a site so AI answer engines like ChatGPT, Claude, and Perplexity can find, understand, and cite it accurately.
What a Production AI Project Actually Costs
A production AI project typically costs $15k to over $200k, driven by complexity, evaluation needs, and robustness requirements.
Can AI Automate Your Process? Ask These 4 Questions.
Before investing in AI automation, ask four critical questions: Is the input consistent? Is the logic describable? Is the output verifiable? Is the volume worth it?
AI Agent vs. Chatbot: An Agent Acts, a Chatbot Responds
A chatbot answers questions. An AI agent, however, executes multi-step tasks using external tools and memory, acting autonomously to achieve a goal.
How long does it take to build a production AI agent?
A reliable production AI agent takes 2–3 months to build. The demo takes a week, but the gap is evaluation pipelines, fallback handling, and edge cases.
The unglamorous ops work behind production AI
What happens after the AI demo: managing P99 latency, sanitizing PII from prompt logs, and handling malformed JSON failures in production.
Don't Ship AI Features to 100% on Day One
Gradual rollouts, A/B testing, and shadow mode are critical for AI features. Learn how to instrument and deploy safely.
How We Evaluate LLMs: Beyond Benchmarks
Stop guessing which LLM works best. Our framework helps you pick the right model for your task, measuring cost, quality, and long-term fit.
Stop Hitting LLM Rate Limits: What We Learned Shipping
Learn production patterns for rate limiting AI endpoints, including per-user, cost-based, and queue-based throttling, to avoid provider limits and unexpected bills.
Rules Still Win: When Not to Use an LLM
LLMs aren't a silver bullet. We break down TelaLoom's decision tree for when deterministic rules outperform AI models.
Self-Hosting LiteLLM: What We Learned (and Why Our Products Call Providers Directly)
We self-hosted LiteLLM for internal tools while our products called providers directly. Here's when a gateway earns its place, and the backup lesson we learned the hard way.
Building AI Feedback Loops That Don't Require Manual Labeling
Stop waiting for user ratings. Learn how to build a reliable AI evaluation framework using automated checks, sampling, and implicit signals.
Token Cost Optimization: Where the Savings Actually Are
The highest ROI strategies for reducing LLM token costs in production: prompt caching, model routing, context trimming, and output constraints.
How to Add AI to an Existing SaaS Without Rewriting It
Most SaaS products don't need a rebuild to get AI features. They need one well-chosen workflow, a clean API endpoint, and a prompt that doesn't hallucinate on your data. Here's the pattern we use.
What an AI Automation Sprint Actually Looks Like
A fixed-scope, fixed-price, four-week AI automation engagement. Here's what happens each week, what you get at the end, and what we won't scope in.
LLM Routing: When to Put Claude, Gemini, and OpenAI Behind One Gateway
Hard-coding a single model provider into your app is a liability. Here's how to route across Claude, Gemini, and OpenAI — and the rules for deciding which model runs which task.
The AI Features That Actually Show Up in Your P&L
Most AI features don't move the needle. A few do — reliably and measurably. Here's how to tell the difference before you build, with examples from production.
Webhook vs Polling for AI Integrations: When Each Makes Sense
Both patterns work for AI integrations. The right choice depends on latency requirements, whether the data source emits events, and how much retry logic you want to own. Here's how we decide.