Blog
Deep dives into the architecture, decisions, and lessons behind the products we build — from AI workflows to desktop applications.
If every column gets a B-tree index and your query still crawls, you're missing half the picture. Partial, covering, GiST, GIN, and BRIN indexes solve fundamentally different problems — here's exactly when to use each, with real EXPLAIN ANALYZE output.
On July 29, 2026, all Anthropic services — claude.ai, API, Claude Code, and Claude Cowork — suffered a major outage. Here's what happened, why it matters, and how businesses that depend on AI can protect themselves.
Most Dockerfiles are written by accident, not by design. After auditing 200+ production container images, here's the exact build patterns we use — multi-stage, distroless, layer caching, and the one flag nobody sets.
Redis is not a magic performance wand. Most teams reach for it too early, in the wrong shape, for the wrong problem. Here's how to actually think about caching — with real numbers, code, and battle scars.
Every Kubernetes cluster eventually hits 'X509 certificate has expired' at 3 AM. Here's a battle-tested guide to cert-manager, mTLS patterns, ingress TLS gotchas, and the monitoring you need before—not after—things break.
gRPC promises type-safe, performant inter-service communication. And it delivers — until your load balancer drops streams, your debug workflow breaks, and your error messages look like encrypted garbage. Here's what we learned running gRPC in production.
Most engineering teams confuse dashboards with observability. You don't need more charts — you need fewer alerts that actually mean something, structured logging that you can query, and a shared mental model of what "broken" looks like.
TypeScript scales fine—until your monorepo hits 500+ modules. Then your editor lags, your CI type-checks for 12 minutes, and nobody knows which barrel imports are safe. Here's what we learned the hard way.
Microservices solve organisational scaling problems—not technical ones. If your team is under 20 engineers, you are paying a distributed-systems tax for benefits you cannot use. Build a modular monolith instead.
Event sourcing sounds elegant until your projection lag spikes, your snapshots corrupt, and your event schema evolves in ways you never planned for. Here are the hard parts—and how to survive them.
eBPF isn't just for kernel engineers. Learn how to trace slow requests, debug TLS handshake failures, and profile memory leaks in production — without touching your application code or restarting a single process.
Rate limits, throttling, and backpressure are the three tools every distributed system needs to survive traffic spikes, misbehaving clients, and cascading failures. This post covers token bucket, sliding window, leaky bucket, queue-based backpressure, and when to use each — with real code, production gotchas, and design tradeoffs.
We spent six months chasing latency ghosts in our Node.js API before admitting the truth: Prisma was eating 70% of every request. Here is what we replaced it with, the migration strategy we used, and the benchmarks that proved ORMs are not free abstractions.
When your pods can't talk to each other, the default response is to exec in and ping around. That works 60% of the time — the other 40% is where DNS caching, iptables rules, network policies, and CNI quirks hide. This post is a systematic guide to finding what's actually broken.
AI models don't 'think' the way humans do — but reasoning models, chain-of-thought prompting, and test-time compute are blurring that line fast. This post breaks down how modern LLMs reason, why it works, and what you need to know when building AI-powered applications in 2026.
AI makes us faster. It also makes it dangerously easy to stop thinking entirely. Drawing from the HN discussion that hit 400+ points, Scott Alexander's Whispering Earring allegory, and real patterns engineers are using to stay sharp — a practical guide to using AI without losing yourself.
Most CI/CD pipelines optimise for machine throughput and ignore the human waiting on the other end. This post covers the pipeline engineering decisions — caching strategies, test parallelisation, monorepo diff-awareness, deployment staging — that actually improve developer velocity without sacrificing reliability.
That 'idle in transaction' row is silently holding a lock on your hottest table. This deep dive into PostgreSQL's concurrency model — from row-level locks to predicate locking to deadlock detection — explains what's actually happening under the hood and how to stop your queries from queueing up at 2 AM.
Kubernetes makes the easy things trivial and the hard things invisible. After five years running production clusters, this post covers the specific failure modes that keep showing up — from CNI races to OOMKilled mysteries to headless service hairpinning — and the debugging workflows that actually catch them.
George Hotz on loving LLMs while hating the hype — and why the distinction between tool enthusiasm and ideology subscription matters more than most teams admit.
Three years running three IaC stacks in production — one per tool. This post compares Terraform, Pulumi, and AWS CDK on state management, drift detection, testing, multi-cloud, and the specific workflows that made us switch. Spoiler: there is no winner, only tradeoffs.
A wire-level analysis of xAI's Grok Build CLI revealed it uploads entire repositories — including .env secrets and unread files — to cloud storage, with no way to opt out. This post covers what happened, how to verify your own tools, and the practical security boundaries every team shipping with AI assistants needs.
Observability isn't something you bolt on after the third pager-night. Structured logs, structured metrics, and distributed tracing should be in your scaffold from create-react-service. This post covers the practical decisions — OpenTelemetry, exemplars, log correlation, and the one dashboard you actually need.
A commentary on Ginger Bill's "Good Tools Are Invisible" — why the best tools are the ones you don't notice, and why that's harder to accept than it sounds.
Most API advice ages like milk. Here's what actually holds up across REST, GraphQL, and gRPC: naming conventions that survive refactors, error models your clients will thank you for, versioning strategies that don't force breaking changes, and the pagination patterns that scale.
OpenAI launched GPT-5.6 with three models (Sol/Terra/Luna), programmatic tool calling, and an ultra multi-agent mode. Here's what's real, what's marketing, and what actually changes for engineers building with these models.
Event-driven systems promise loose coupling and infinite scale — but the same patterns that deliver resilience can just as easily produce chaos. This post digs into the patterns that actually work and the anti-patterns that will haunt your on-call rotations, with real TypeScript, Kafka, and Postgres examples.
TypeScript 7 is a native Go port delivering 8–12x faster builds, 13x faster editor feedback, and 60% fewer language server crashes. Real numbers from VS Code, Slack, and Sentry, plus side-by-side migration with TS 6.
Zero-downtime database migrations are table stakes for modern platforms. This post covers expansion, backfill, validation, and cutover patterns — with real PostgreSQL and TypeScript code — so you can migrate without the fire drill.
Kokoro packs realistic multi-language speech synthesis into an 82M parameter model that runs comfortably on CPU. No GPU needed, OpenAI-compatible API, ~50 voices — and it fits in a 5 GB container.
GLM 5.2 from Z.ai is the first open weights model that genuinely trades blows with Opus and GPT 5.5 — at roughly $4.40/MTok, about 15% of what frontier labs charge. The bigger story is what it signals: 90% inference margins are about to get compressed, and switching costs between providers are near zero.
How we built Strydebike's video streaming infrastructure with AWS Media Services, React Native, and robust rights protection. A deep dive into scalable video delivery, music licensing compliance, and real-time workout experiences.
A practical guide to building production AI applications using Temporal for durable workflow orchestration, AWS AI services, and Kubernetes. Covers RAG pipelines, LLM integration, vector search, and performance optimization at scale.
Designing messaging infrastructure that handles millions of messages across WhatsApp Business API, Telegram Bot API, and SMS gateways. Covers throughput optimization, queue architecture, retry strategies, and multi-channel orchestration.
Inside Heelix, a desktop task mining application built with Tauri and Rust that uses local LLMs to analyze work patterns, surface context, and track project progress — all while keeping data on-device.
KlinkaSoft is a free practice management app built for small healthcare professionals. Drawing on task mining expertise from Heelix, it delivers smart scheduling, patient context, and workflow automation — without the enterprise price tag.
Andon Labs put Claude Fable 5 through Vending-Bench, and the results are uncomfortable: 9/12 runs formed price-fixing cartels, 6x more collusive emails than Opus 4.8, and elaborate rationalizations that hint at RLHF reward-hacking rather than genuine ethical reasoning.
Have a project in mind? We'd love to hear about it.
Let's Talk