The Art of Caching: State Management in GraphQL UIs
Efficient data fetching is only half the battle. This post explores the art of client-side caching, from the magic of normalized data in Apollo/Relay to bulletproof invalidation strategies and SSR hydration. Learn why great caching is as much about predictability as it is about performance.
Beyond useQuery: Advanced Data Fetching in GraphQL
Stop request waterfalls and N+1 problems at the source. This deep-dive covers advanced GraphQL data fetching patterns like fragments, query batching, cursor-based pagination, and real-time subscriptions to build truly performant clients.
Why Frontend Performance Starts at the API
Modern frontend performance bottlenecks often originate at the API layer. Instead of just identifying the problem, this post provides a blueprint for a solution, covering data fetching, caching, SSR, and more, kicking off a deep-dive series into building truly high-performance UIs.
Postgres Full-Text Search vs. Embeddings: A Practical Guide
Most teams reach for embeddings before they need them, wiring up pgvector when Postgres’s full-text search would have done the job. If your users are just looking for “caching” and expect to find “Rails caching strategies,” full-text search is fast, precise, and already built in. Where embeddings shine is when meaning matters more than exact words, like an e-commerce query for “summer outfit” that should return linen shirts and beach dresses. The key isn’t choosing one tool over the other, but knowing when Postgres alone is enough and when a hybrid approach gives you the semantic nuance users actually need.
How I Reduced API Latency by 50% Using Strategic Redis Architecture
Peak traffic was crushing our API—P95 latency at 450ms, dashboards taking 5 seconds to load, and users complaining of “slow mornings.” By introducing a Redis caching layer designed around real access patterns, not just generic key-value storage, we cut P95 latency in half, reduced DB CPU load from 85% to 45%, and eliminated the majority of timeouts. This is the story of how intentional caching turned a struggling system into one that scaled gracefully.
How I Built Promptly: Solving AI Prompt Management at Scale
The moment I realized we had a problem was when our QA engineer asked, 'How do we know if someone accidentally changed how the AI behaves?' We had prompts scattered across a dozen files, each slightly different, with no way to test or version them. It hit me: we were making the same mistakes Rails solved 15 years ago with hardcoded strings. AI prompts aren't just text, they're critical business logic that shapes user experience. So I built Promptly to bring Rails conventions to AI development, treating prompts like the first-class citizens they should be. The result? 60% faster AI feature development and actual regression testing for AI behavior. Sometimes the best solutions aren't about new technology; they're about applying proven patterns to new problems.
Caching with intent: How to avoid the Redis graveyard
Effective caching strategies require intentional design to prevent memory waste and stale data issues. Implementation guidelines include evaluating query cost, frequency of access, data predictability, TTL settings, and scope management for optimal Redis performance.
Legacy Code And The Trap Of False Consistency
Maintaining consistency in legacy codebases can become a barrier to improvement when it preserves bad design patterns. Effective refactoring requires distinguishing between beneficial consistency and resistance to necessary change.
🚨 Introducing GemGuard: Automated Security for Ruby Gems (Scan, SBOM, Typosquat, Auto-Fix)
GemGuard is my attempt to make Ruby security less of a chore and more of a natural part of development. It scans your Gemfile.lock against OSV.dev and the Ruby Advisory Database, flags typosquat risks, and can even generate SBOMs in SPDX or CycloneDX formats. If it finds a vulnerable gem, it’ll suggest or apply safe upgrades, and because it’s designed with CI/CD in mind, you can drop it into your workflow without slowing things down.
Designing for operations
Operational excellence in system design prioritizes maintainability and debuggability alongside performance. Key practices include stable API contracts, structured logging, idempotent operations, and proactive error handling to reduce operational overhead.