Blog: Engineering Essays & Field Notes

Field notes from the Denshin team: engineering essays, AI guides, product write-ups, post-mortems and lessons from shipping software in production.

Agentic AI explained: what actually works in production: An agent is a specific thing: a system where the model, not your code, decides the next step. How agents differ from chatbots and LLM workflows, where they beat a scripted pipeline, the failure modes that cost real money, and a checklist for scoping your first one.
Serverless math: when Lambda is cheaper than a server, and when it isn’t: The actual math we use to choose between AWS Lambda and a server: the idle-cost floor, the requests-per-second crossover, cold-start billing, and the operational cost nobody puts in the spreadsheet.
What a SaaS MVP actually costs, and where the money really goes: Real ranges for a SaaS MVP in 2026, why the code is the cheap part, and the three line items founders almost always underestimate, from a studio that quotes these for a living.
Denshin × Anthropic Claude Code: How AI Pair-Programming Reshaped Our Delivery: How Denshin uses Anthropic Claude Code to scaffold features, run cross-cutting refactors, generate tests, and ship migrations in a single afternoon, without giving up code review discipline.
DynamoDB single-table design at small scale: what actually mattered: After a few years running production DynamoDB single-table designs for small SaaS apps, the parts that earned their keep, and the parts that bit us.
Field notes from building a houseboat booking system in Kerala: Pricing as a function, internet that comes and goes, and the booking flow that starts as a WhatsApp message: what we learned shipping a real-world reservation system on the Kerala backwaters.
Fixing slow clicks in a React admin panel: Admin panels are rarely slow to load, they are slow to use. What INP measures, the React patterns that make clicks and keystrokes lag, and the fixes we reach for first.
Before you roll out Microsoft 365 Copilot, look at who can see what: Copilot can only use what each person can already open, which is exactly why oversharing in SharePoint and OneDrive becomes a problem the day it is switched on. The cleanup to do first, and how to run the pilot.
Our typecheck script checked nothing: In our Turborepo monorepo, tsc --noEmit ran against a solution style tsconfig with an empty files list, checked zero files and passed every time. A short note on project references and on proving a check can fail.
What you should get when a software studio hands over your project: The app works, everyone is happy, and six months later the domain is in an ex-developer's name. A plain checklist of what you should own, and be able to do, when a studio hands over your project.
AI browser testing or Playwright scripts? We use both, for different jobs: Scripted Playwright tests and AI agents that drive a browser solve different problems. Where each one earns its place, what agents still get wrong, and the hybrid workflow we run on testing projects.
Fixed price or time and materials: how we actually decide: Fixed price moves the risk to the studio, which prices it in. Time and materials leaves it with you. How we decide between the two, and the split we recommend for most new products.
Notes from wiring GST e-invoicing into a billing system: Engineering notes for adding GST e-invoicing to an ERP or custom billing app: the 30 day reporting limit and 24 hour cancellation window, idempotent IRN calls, validation, locked invoices, credit notes and what to store.
Replacing a spreadsheet workflow without starting a revolt: The software is rarely why a spreadsheet replacement fails. A few habits that get a team to actually let go of the shared sheet: watch first, keep the export, import the history, run both for one cycle.
What goes into a good Claude skill: A skill is a folder with a SKILL.md file, and most of its quality comes from a few unglamorous choices: a description that matches real requests, short instructions, scripts for anything with a right answer, and testing it like code.
Our brand colour failed contrast, so it got a darker sibling: Our bronze accent measured about 2.5 to 1 on cream, well short of WCAG AA for text. We kept the colour and added a darker ink token for text on light grounds. What changed, what stayed bright, and what still fails.
Pre-rendering head tags for an SPA, and the regex that failed quietly: Crawlers that do not run JavaScript saw our homepage title on every URL. How we stamp per-route HTML at build time on S3 and CloudFront, and the fifteen minutes when a silent regex miss shipped the wrong canonical.
Why developers should not be the only people testing their software: Developers test the path they built. Users take a different one. What an independent testing pass actually covers, what a useful bug report looks like, and when a separate QA team is overkill.
WhatsApp's October 2026 pricing change, from the side that writes the code: From 1 October 2026 WhatsApp charges for service replies past 1,000 a month and for utility templates inside the customer service window. What changed, what it costs at Indian rates, and how we now design order updates and support flows.
Heavy motion, cheap phones: we tier the animation instead of cutting it: Our GSAP heavy homepage stuttered on low end phones. Instead of stripping it, we pick full, lite or static motion per device, with a frame time watchdog, a URL switch for testing, and two ScrollTrigger traps that left content invisible.
DPDP Rules: what product teams actually have to change before May 2027: The DPDP Rules were notified in November 2025 and most obligations apply from May 2027. How notices, consent records, breach reporting, retention and vendor contracts turn into engineering tickets, and a rough seven month plan.
The small AWS charges that quietly add up on small projects: Public IPv4 addresses, idle NAT gateways, log groups that never expire, forgotten stacks and incomplete multipart uploads. The small line items we find most often in small AWS accounts, and the one budget alert that catches them.
Renaming a URL without losing what it earned: We moved /projects to /collaborations on a static S3 and CloudFront site. A real 301 from a CloudFront Function, a fallback stub because s3 sync never deletes, the deploy order that matters, and the two URLs we forgot.
AI agent architecture: tools, memory and the loop: The loop is the easy part of an agent. The hard parts are the tools you expose, the memory you carry between turns, and the permission layer around anything that writes. A working architecture for a production agent, including tool design, error messages as prompts, and when a state machine wins instead.
Model Context Protocol (MCP) explained for engineering teams: MCP is an open protocol for connecting AI clients to tools, resources and prompts, so an integration written once works across clients. What the pieces are called, when to write a server instead of a plain REST API, and why a server runs with the permissions of whoever authorised it.
How to evaluate AI agents: evals that catch real failures: It looked good in the demo is not a test. How to build an eval set from real traffic and bug reports, the four types of eval and what each one catches, why agents need trajectory evaluation and not just final-answer scoring, and how to upgrade a model without gambling.
RAG vs fine-tuning: how to choose: RAG changes what a model knows, fine-tuning changes how it behaves. A practical decision framework covering data freshness, citations, per-user permissions on source documents, tone consistency, latency and cost, and the ops burden of a training pipeline, plus the hybrid most production systems actually land on.
RAG chunking strategies that actually improve answers: Most bad RAG is a retrieval problem, not a model problem. A practical guide to fixed size, recursive, structure aware and semantic chunking, overlap that pays for itself, metadata worth keeping, handling tables, code, PDFs and scans, parent document retrieval, hybrid search, reranking, and measuring recall@k first.
Vector databases and embeddings explained without the hype: What an embedding really is, what similarity does and does not capture, and how to choose between an in-memory index, pgvector in the Postgres you already run, a managed search service and a dedicated vector database. Plus ANN recall trade-offs, re-embedding migrations, dimension cost, metadata filtering and index sync.
Structured outputs and tool calling: the glue of AI features: The unglamorous layer that decides whether an AI feature ships: schema-constrained output versus asking for JSON in the prompt, designing schemas a model can fill correctly, validating with Zod at the boundary, repair retries and fallbacks, and tool calling rules on argument validation, idempotency and untrusted identifiers.
Context engineering: the skill that replaced prompt engineering: Prompt wording is no longer the hard part. The hard part is deciding what enters the context window, in what order, and at what cost. A practical guide to the context budget, the failure modes of a stuffed window, and the techniques that reclaim it.
Prompt engineering best practices that survive model upgrades: Some prompt techniques keep working when the model underneath changes. Others were only ever workarounds for one version's quirks. Here is how to tell them apart, plus the operational practices that make a model upgrade routine: prompts in the repo, versioned, tested against an eval set.
Small language models vs frontier models: when smaller wins: Routing every call to the biggest model is an expensive default. Small models now handle classification, extraction, routing and short summarisation well, while frontier models still earn their price on long-horizon reasoning and agentic work. How to build a cascade that escalates only when it needs to.
AI coding agents: guardrails for shipping real software: Vibe coding is fine for a prototype and dangerous as a delivery method. The guardrails that make AI-written code safe to ship: a conventions file the agent reads first, tests and typecheck as the feedback loop, small diffs, permission gates on anything irreversible, and a named human who owns the PR.
Prompt injection and AI guardrails: a defender's checklist: Prompt injection is a design problem, not a filter problem: a language model cannot reliably tell instructions from data, so any untrusted text that reaches the context is potential instruction. A defensive guide to least privilege for tools, human confirmation, output encoding, exfiltration through rendered links, and a pre-launch checklist.
Rumoured AI models: how to read the hype cycle: A media literacy guide to AI model rumours for engineering and product leads. How rumours are made, why anticipated capability jumps are announced far more often than they arrive, a checklist for verifying a claim against primary sources, and the practical part: building so that swapping models is a config change.
Choosing an LLM: a decision framework, not a leaderboard: Public leaderboards are a weak signal for your specific workload. A practical framework for choosing a model: the dimensions that actually decide it, a weighted scorecard, a two week bake off that fits in a sprint, and an honest look at whether multi-provider support is worth its complexity.
Open-weight models: when self-hosting makes sense: An honest cost and control analysis of running open weight models yourself. What open weight really means, why the licence matters, the genuine reasons to self-host, the costs teams underestimate, the managed inference middle path, and a decision rule that starts with a hosted API and measurement.
Generative engine optimization: how to get cited by AI search: AI search answers questions without sending a click. Generative engine optimization is not a replacement for SEO, it is the same fundamentals plus passages that survive being lifted out of context. What makes content citable, which structured data matters, and how to measure it honestly.
llms.txt and AI crawlers: what to put on your site: A practical guide to the machine readable layer of a website: what llms.txt is and why it is a proposal rather than a standard, how to tell training crawlers apart from the retrieval fetchers that power AI citations, and the robots, sitemap, canonical and rendering work that definitely matters.
AI customer support that does not annoy your customers: Most support bots fail because they were bought to deflect tickets, not to solve problems. A practical design guide: answer from your documentation with citations, make 'I don't know' a real outcome, keep the human handoff one click away, never let the bot commit the business, and measure resolution instead of deflection.
AI for Indian SMEs: where it pays off first: A grounded adoption guide for Indian small and mid-sized businesses. The returns show up first in repetitive, document heavy work: invoice and GST paperwork extraction, quotation drafting, WhatsApp replies, catalogue content, and internal search over SOPs. What to avoid, the four prerequisites that decide success, and a quarter long sequence.
The pre-launch checklist we run before shipping a client’s site: Empty states, error paths, SEO, Core Web Vitals, security headers, backups, and the handover test: the practical checklist that keeps a launch calm instead of catching fire.
What to actually ask a software studio before you hire one: The questions that surface how a studio really works: code ownership, the admin panel, communication cadence, estimation honesty, security, and what happens after launch.
Adding AI to your product without setting money on fire: LLM prices fell ~80% in a year, but careless integration still burns runway. Model routing, prompt caching, evals, and the boring scaffolding that turns an AI demo into a production feature.
On hating React Query for two days, then reaching for it forever: A frank account of why TanStack Query feels wrong before it feels right, the mental shift that fixed it, and the conventions we now bring to every project.
We ship the admin panel with the product. Always.: Why we treat the admin panel as part of v1, not a follow-on, and why that single decision has outsized effects on client trust and product quality.
The boring stack still wins for 90% of client work: An honest defence of the unfashionable stack (React, Vite, Tailwind, Lambda, DynamoDB), and the calibration we use before adopting anything new.
How we estimate when nobody really knows: Estimating software is mostly lying with units. A few small habits (separating knowns from unknowns, tracking our own calibration, naming the buffer) make us less wrong.
S3 + CloudFront for an admin-heavy SPA: the boring wins: Why we still host most admin panels on S3 and CloudFront, what we miss compared to the newer hosting platforms, and what we don't miss at all.
Why Zod replaced our hand-rolled validators: We resisted Zod for a while. The migration took a sprint and we never looked back. Here's what changed, what it cost, and why the inferred types matter more than the schemas.
The bug that made us stop trusting timestamps: A Sunday-afternoon double-booking incident, the timezone mismatch behind it, and the two house rules we wrote afterwards that have prevented it from happening again.

Services · Collaborations · Our Products · Team · Blog · Contact

Denshin, 501, 5th Floor, Sangriya, Balewadi, Pune, Maharashtra 411045, India · admin@denshin.in · +91 95954 21959