The LetRelay Blog
Playbooks for running a calm, fast internal help desk.
LLM Tool Calling for Internal Assistants: Design Choices
How to give an internal AI assistant tools — reading workspace data with the user's permissions, formatting results for the model, native function calling vs a routing step, limits on how many tools run, and answers that stay inside the data.
Facilities Request Management: From Broken Chairs to Keys
How to run facilities requests like a proper service — categories, location on every request, safety issues that skip the queue, vendor work, recurring maintenance and the numbers that show where the building needs attention.
Building a Multilingual Chatbot That Handles Romanized Text
Real users mix languages and scripts — Nepali in Devanagari and in Latin letters, Hinglish, English with local words. How to route, retrieve, parse dates and reply in the right script, with lessons from a production assistant.
On-Call Rotation for a Small IT Team: A Fair, Sustainable Setup
How a small IT team can cover urgent issues out of hours without burning out — what's worth being paged for, rotation length, handovers, runbooks, compensation, and reviewing every page.
Stop Your Product Chatbot from Hallucinating Features
A help chatbot that invents buttons, settings and features is worse than no chatbot. How we fixed ours — a feature registry checked against the real UI, retrieval that finds the right page, strict grounding rules, link guards and must-not-include evals.
IT Asset Management for Small Companies: A Lightweight Approach
A practical IT asset management setup for small companies — what to track, one record per asset, lifecycle states from purchase to disposal, linking assets to people and requests, and the security reasons it matters.
Scheduled Jobs in Supabase with pg_cron: A Practical Guide
How to run scheduled jobs inside Postgres on Supabase with pg_cron — idempotent schedules in migrations, catch-up logic, locking down job functions, outbound HTTP with pg_net, monitoring runs, and the free-tier pause.
HR Service Desk: Handling Employee Requests Without the Inbox
How an HR service desk works — categories for pay, leave, contracts and benefits, privacy that's enforced not promised, targets that respect deadlines like payroll, self-service for policy questions, and the metrics HR can use.
Caching LLM Responses Safely: What to Cache and What Never To
Caching LLM answers saves tokens and latency — and can leak one user's data to another if done carelessly. A safe design: cache only answers that are identical for everyone, key on normalized question plus content version, expire, and lock the cache down.
IT Outage Communication: Templates for Every Stage
Clear outage messages cut duplicate tickets and frustration. Copy-ready templates for the first notice, updates, resolution and the follow-up review — plus who sends them, where, and how often.
Validate Next.js Server Actions with Zod (and Authorize Them)
Server Actions are public POST endpoints. How to validate every input with Zod, check authentication and authorization inside each action, return safe errors to forms, and keep secrets and database logic server-only.
Shared Inbox vs Help Desk: When to Switch
A shared inbox is fine until two people answer the same email and a third goes unanswered. What a shared inbox does well, where it breaks, what a help desk adds, and the signals that it's time to switch.
Intent Routing with Small LLMs: Fast, Cheap and Right
How to route chat messages to the right action or tool with a small, fast language model — a flat strict schema, deterministic argument extraction, rules before the model, a short timeout, and a 51-case evaluation — using measurements from a production assistant.
Access Request Approval Workflow: A Practical Design
A secure, fast workflow for access requests — what to ask for, who approves (the manager and the data owner), time-limited access, separation of duties, provisioning, and periodic access reviews.
How to Reduce LLM Token Usage Without Worse Answers
Practical ways to cut LLM token usage — skip the model when rules suffice, send less context, route to smaller models, cache repeated answers, use provider prompt caching and cap output — with measured numbers from a production assistant.
Help Desk Escalation Matrix: A Template and How to Use It
An escalation matrix says who gets pulled in, when, and how — by priority and time. A template for internal help desks, functional vs hierarchical escalation, triggers that aren't just time, and how to keep escalation from becoming noise.
Supabase Security Definer Functions: The Exposure You Might Miss
In Supabase, public-schema functions are callable over the API — and SECURITY DEFINER ones bypass row-level security. What our audit found in 117 such functions, the real damage paths, and the grants and rules that close them.
How to Write Knowledge Base Articles People Actually Use
A practical guide to writing internal knowledge base articles — titles in the reader's words, the answer first, numbered steps, screenshots used sparingly, a fixed template, and ownership so articles stay true.
Timezone Bugs in Web Apps: The Ones We Actually Hit
Real timezone bugs from a production app — a due date showing the previous day, "today" starting at the server's midnight, server-rendered times in the wrong zone — why each happened, and the rules that prevent them.
How to Reduce Password Reset Tickets (Securely)
Password resets are one of the most repetitive help desk requests. Cut them with self-service reset, fewer passwords (single sign-on), modern password rules from NIST, and a secure verified process for the resets that still reach a human.
AI Agent Actions with Human Confirmation: A Design Pattern
How to let an AI assistant take real actions — create tasks, request leave, book meetings — safely: propose with structured fields, show an editable confirmation card, execute the confirmed values through existing server code, and report the result.
Help Desk Ticket Categories: Examples and How to Design Them
A practical guide to help desk ticket categories — how many to have, example category lists for IT, HR, finance and facilities, what each category should carry (team, type, target), and how to fix a category list that isn't working.
RAG for Internal Documentation: A Small-Team Guide
How to build retrieval-augmented generation over your internal docs without a big platform — structuring documents for retrieval, hybrid search, small prompts, grounding rules, permissions, and measuring whether answers are right.
Employee Offboarding Checklist: Removing Access Safely
A step-by-step IT offboarding checklist — timing with HR, disabling sign-in first, transferring ownership, recovering devices, removing SaaS and shared credentials — so former employees don't keep access and nothing important is lost.
Prompt Injection in Internal AI Tools: A Practical Defense
Internal AI assistants read tickets, documents and messages written by other people — which makes prompt injection an internal threat too. How direct and indirect injection work, and the layered defenses that actually limit the damage.
IT Onboarding Checklist for New Employees
A complete IT onboarding checklist — before day one, day one and the first week — covering accounts, devices, access by role, MFA, security basics and how to run it as a repeatable request so nothing depends on memory.
How to Evaluate an LLM Feature with a Golden Set
A practical way to test LLM features before shipping changes — a golden set of real inputs, deterministic checks for what must and must not appear, separate evals for retrieval, routing and answers, and running them on free-tier rate limits.
Incident vs Service Request: The Difference and Why It Matters
An incident is something broken that should work; a service request is someone asking for something standard. How to tell them apart, why they need different targets and workflows, and how to design intake so people don't have to know the difference.
Generative Engine Optimization (GEO): What Actually Works
How to get cited by AI search — Google AI Overviews, ChatGPT search, Perplexity — based on what the research and the platforms' own documentation say, not guesses. Crawlers, content, structure, and what doesn't work.
How to Build an Internal Help Desk with Next.js and Supabase
The architecture behind a production internal request desk — Postgres row-level security for tenancy, SLA timers the database computes, and AI that helps but never blocks — on free tiers.
How to Cut First-Response Time in Half on an Internal Desk
First-response time is mostly waiting, not work. A seven-step playbook — one front door, clean routing, a visible queue, triage rotations and honest measurement — to halve it.
Supabase Row-Level Security for Multi-Tenant Apps: A Guide
A production pattern for multi-tenant isolation in Supabase — one organization_id column, security-definer helpers, policies that combine tenant and role, triggers that fill the tenant, and tests that prove it.
A Free AI Gateway: Gemini + Groq Failover That Stays Fast
How to put several free AI providers behind one function — per-use-case model chains, cooldowns on 429s and timeouts, no interactive retries, and the measurements that showed why each rule exists.
Semantic Search for a Knowledge Base with Supabase pgvector
Build semantic search over a help desk knowledge base with Supabase and pgvector — embeddings, an HNSW index, a similarity threshold, hybrid keyword search, and the multi-tenant security mistake to avoid.
What Is an Internal Request Desk? A Plain-English Guide
An internal request desk is one place where employees ask IT, HR, finance or facilities for help — and every ask gets an owner, a status and a deadline. Here's how it works and when you need one.
Help Desk SLA Tracking: Targets, Timers and Breaches
How to set SLA targets an internal help desk can actually meet, measure first response and resolution correctly, and catch breaches before they happen.
Ticket Deflection with a Self-Service Knowledge Base
Ticket deflection means answering a question before it becomes a ticket. How to build a knowledge base people actually find — suggestions while they type, semantic search, articles written from real requests — and how to measure deflection honestly.
Free Help Desk Software: What You Actually Get
What free help desk plans typically include and leave out — seats, SLAs, automation, AI, reporting, data export — the hidden costs, and a checklist to evaluate any free plan before your team depends on it.
Next.js App Router + Supabase Auth: The SSR Setup That Works
Two clients, a proxy that refreshes the session, getClaims or getUser instead of getSession, and a layout gate — the Supabase SSR auth setup for the Next.js App Router, with the mistakes that cause random logouts and leaks.
Streaming AI Responses in Next.js: Plain Streams vs SSE
How to stream LLM answers from a Next.js Route Handler to the browser — a plain ReadableStream or Server-Sent Events, reading it with fetch, saving before the stream closes, and falling back when the model fails mid-answer.
Build a Kanban Board in React with dnd-kit (and Postgres)
A production kanban board with dnd-kit — sensors for mouse, touch and keyboard, sortable columns, fractional positions stored in Postgres, optimistic moves that roll back, and accessibility built in.
AI Request Classification with Structured Output
How to classify help desk requests with an LLM using structured JSON output — schema design, validation, confidence thresholds, free-tier limits and the fallback path — so a wrong or missing answer never breaks intake.
Internal IT Help Desk Best Practices for 2026
Twelve practices that separate a calm internal IT help desk from a chaotic one — one front door, deadlines by request type, honest metrics, self-service, security basics, and AI that helps without taking over.
Support Ticket Routing: Getting Requests to the Right Team
Every misrouted ticket waits twice. How to route requests to the right team — requester choice, rules, AI suggestions — how to measure routing quality, and what to do when it fails.
Help Desk Metrics That Matter (and the SQL Behind Them)
Seven help desk metrics that drive decisions — first response, resolution, SLA attainment, backlog age, reopen rate, reassignments and deflection — with definitions, pitfalls and the queries to compute them.
How AI Is Changing IT Service Management (and What It Can't Do)
Where AI genuinely helps IT service management today — intake, triage, knowledge, drafting, assistants that act with confirmation — where it doesn't, and how to adopt it without betting your service desk on a model.
SLA vs OLA vs KPI: What's the Difference?
An SLA is a promise to the people you serve, an OLA is a promise between internal teams that makes the SLA possible, and a KPI is a number you watch to see how you're doing. Examples and pitfalls for each.
Managing Request Priorities Without Chaos
When everything is urgent, nothing is. How to set request priorities with an impact × urgency matrix, stop priority inflation, sort the queue by deadline, and handle the VIP and the genuine emergency.
Onboarding Your Team to a New Help Desk Tool
New tools fail from low adoption, not missing features. A practical plan to onboard agents and requesters to a new help desk — a pilot team, the first week's habits, redirecting kindly, measuring adoption and retiring the old channels.
How to Book Internal Meetings Without the Back-and-Forth
Book time with a colleague in one step — see when they're busy, propose a time, and let them accept, reschedule or decline. How the request → approve model works, privacy-safe free/busy, video links and timezones.
Slack and Discord to Tickets (and Back) with Webhooks
Turn chat messages into help desk tickets with signed inbound webhooks, and post ticket updates back to Slack or Discord — with HMAC verification, idempotency, retries with backoff, and SSRF-safe URLs.
Role-Based Access for Internal Tools: A Practical Design
How to design role-based access for an internal tool — a few flat roles, additive grants for special cases, enforcement in the database, and UI that mirrors it — without ending up with a permissions spreadsheet nobody understands.
SaaS on Free Tiers: An Architecture That Actually Holds
How to run a real SaaS on free tiers — Supabase, free AI APIs, free email — with the actual limits, what breaks first, the commercial-use rules people miss, and the design choices that keep it inside the budget.
Attendance and Leave Management for Small Teams
A practical attendance and leave system for small teams — one-click check-in by default, verified mode only when needed, a clear leave approval flow, tamper-proof records, timezones and privacy done right.
Team Rooms: Focused Spaces for Projects and Incidents
When a ticket is the wrong shape for the work — a launch, an incident, a short project — give the group a private room with chat, a deadline and a way to get attention. How rooms work and when to use them.
How to Track Your Team's AI and API Spend
AI and API costs sprawl across teams and cards until an invoice surprises you. A lightweight way to track spend — an inventory, budgets, a usage ledger, automatic sync where providers allow it, and alerts before renewals and overruns.
An Analytics Dashboard with Plain Postgres (No BI Tool)
Build an in-app analytics dashboard from SQL functions — KPIs, breakdowns, time series and percentiles — that respect row-level security, stay fast with the right indexes, and render with Recharts.
Row-Level Security vs App-Layer Authorization: Which Wins?
App-layer checks have to be remembered on every route; row-level security is enforced on every query. When each is right, how to combine them, and the performance and testing details that make RLS work in production.
The Case for AI That Degrades Gracefully
AI features fail — rate limits, timeouts, outages, wrong answers. Design so the product still works when they do: save first, suggest don't decide, fall back to rules and cached answers, and tell users plainly.