Blog

Stuff we have learned.

Notes from building real products for real clients. The kind of thing you only figure out by doing it.

AI Agents8 min read

We taught an AI to read messy handwritten timesheets

A healthcare staffing company was wasting hours every week typing up timesheet data by hand. Here is how we built an agent that does it in minutes.

#ai#healthcare
Read
Generative AI10 min read

Using three AI models in one product (and why)

FastRead.io uses Claude for writing, Gemini for images, and OpenAI for audio. Here is what we learned about making them play nice together.

#claude#gemini
Read
Enterprise7 min read

When your company wants ChatGPT but compliance says no

We built a private AI chat system that runs entirely on the client's servers. Zero data goes outside. Here is how we set it up.

#llm#compliance
Read
Engineering9 min read

The messy reality of building a ticket resale platform

Scraping inventory, syncing prices across exchanges, handling stale listings. The stuff nobody talks about when they say "just build a marketplace."

#web-scraping#data-pipelines
Read
Computer Vision12 min read

Two years of computer vision in factories: what actually worked

We spent two years building defect detection for glass manufacturing. Tutorials make it look easy. Real factory floors are a different story.

#computer-vision#manufacturing
Read
AI Engineering9 min read

Why our first RAG system failed (and how we fixed chunking and hybrid search)

Vector databases are easy to demo and notoriously tricky in production. Here is why naive semantic search gave our users garbage answers and how hybrid retrieval fixed it.

#rag#vector-search#ai
Read
Backend10 min read

Scaling WebSockets to 50,000 concurrent users without breaking the bank

When a live bidding platform went viral, single-node socket servers choked. Here is how we redesigned real-time state sync with Redis Pub/Sub and horizontal clustering.

#websockets#node.js#redis
Read
Frontend8 min read

Migrating a massive SaaS from Next.js Pages to App Router: The good, bad, and ugly

Server components promise faster load times, but the migration path has landmines. Here are the caching bugs, mental shifts, and architectural choices we navigated.

#next.js#react#performance
Read
Database11 min read

Cutting PostgreSQL query times from 14 seconds to 38 milliseconds

A client dashboard was crashing under 40 million rows. How we used partial indexes, explain analyze, and query refactoring instead of throwing bigger AWS instances at it.

#postgresql#performance#sql
Read
AI Agents9 min read

Building resilient AI workflows: Why stateful graphs beat linear prompt chains

Linear chains fail catastrophically when intermediate model calls hallucinate. How state machine architectures with human-in-the-loop saved our autonomous agent.

#langgraph#ai-agents#python
Read
Architecture8 min read

Why we decomposed three microservices back into a modular monolith

Network hops, distributed tracing overhead, and distributed transactions were slowing down a 12-person team. Here is why consolidating increased feature velocity 3x.

#architecture#system-design#microservices
Read
Fintech10 min read

Building complex usage-based billing with Stripe without losing your mind

Tiered pricing, webhook idempotency, delayed invoice reconciliation, and credit roll-overs. The edge cases they don't explain in checkout docs.

#stripe#billing#saas
Read
Mobile9 min read

React Native vs. Flutter in 2026: What we discovered after shipping both

We rebuilt the same logistics app across both frameworks for real drivers on low-end Android hardware. Here is the raw data on memory, battery, and startup latency.

#react-native#flutter#mobile-dev
Read
DevOps7 min read

Zero-downtime database schema migrations on a high-throughput system

Adding a NOT NULL column with a default value locked tables and caused an outage. Here is our five-step expand-contract migration playbook.

#postgresql#devops#migrations
Read
Security9 min read

Securing production LLM apps against prompt injection and data leaks

How attackers jailbreak system instructions and extract internal API keys through user uploads, and the layered defense system we put in place.

#security#llm#ai
Read
Performance8 min read

How we took an e-commerce site from 42 to 98 on Google PageSpeed

Third-party tracking scripts, font shifts, and heavy hydration were killing conversions. Here is the exact checklist that brought LCP under 1.2s.

#web-vitals#frontend#seo
Read
Cloud10 min read

AWS Lambda vs. ECS Fargate: An honest cost breakdown at 100M monthly requests

Serverless was cheap when starting, but cold starts and invocations added up. Here is the exact inflection point where containerized workloads saved 60% on AWS.

#aws#cloud#serverless
Read
Generative AI9 min read

Fine-tuning vs RAG: When to adapt weights and when to retrieve context

Clients often ask for fine-tuning when they actually need prompt engineering, and prompt engineering when domain style transfer requires LoRA. Here is our decision rubric.

#machine-learning#rag#llm
Read
API Design8 min read

Why we swapped GraphQL for tRPC and REST in our newest client projects

Resolvers became N+1 query nightmares and client bundle sizes crept up. How end-to-end type safety in full-stack TypeScript gave us faster delivery.

#trpc#graphql#typescript
Read
System Design11 min read

Lessons from designing an event-driven transaction pipeline with Kafka

Out-of-order events, poison pill messages, and consumer group rebalancing. What happens when your message bus processes millions of financial events per hour.

#kafka#distributed-systems#event-driven
Read
Design Systems8 min read

Building an accessible component library from scratch that engineers actually love

Why off-the-shelf component libraries often get overridden into unmaintainable spaghetti, and how we structured Radix primitives and Tailwind tokens.

#ui/ux#accessibility#design-system
Read
Backend9 min read

Cache stampedes, dogpiling, and eviction: Redis mistakes we won't make again

When a cache key expired during peak traffic, thousands of queries hammered the primary database at once. Here is how mutex locks and probabilistic early expiration fixed it.

#redis#caching#architecture
Read
Enterprise10 min read

Multi-tenant database architectures: Shared schemas vs. isolated databases

Row-level security, separate PostgreSQL schemas, or individual databases per tenant? A deep dive into compliance, performance, and maintenance overhead.

#saas#database#enterprise
Read
Observability8 min read

What we monitor in production: An opinionated OpenTelemetry and alerting guide

Alert fatigue happens when you page engineers for CPU spikes that don't impact users. How we shifted our alerts to SLOs and user-facing error budgets.

#opentelemetry#monitoring#devops
Read
Testing9 min read

Flaky test suites were slowing releases: How we tamed Playwright CI pipelines

E2E tests that pass locally but fail intermittently on GitHub Actions waste developer hours. Here is how we reduced test flakiness from 28% to under 0.5%.

#playwright#testing#ci/cd
Read

More posts coming soon. We write when we have something worth saying.