Set-Based Updates in Rails: 4 Hours to 8 Seconds
Stop writing N+1 update loops. Learn how `update_all`, `update_columns`, and safe, batched SQL can drastically improve your Rails app's performance.
Read article →Posts tagged with #ruby
Production Observability for Rails Outbox Pipelines: A Guide to Metrics, Alerts, and Runbooks
Go beyond basic reliability. This is a complete operational manual for your Rails outbox, covering the four critical metrics, production-grade processor design with Sentry, forensic runbooks, and the anti-patterns that lead to silent failures.
Read article →Building Bulletproof State Machines: Migrations, Locking, and Audit Trails in Rails
Implicit state is a breeding ground for bugs. We'll refactor a typical Rails model to use a production-ready state machine, covering migrations, race conditions, testing, and audit trails to make your code safer and easier to reason about.
Read article →When the Service Directory Becomes a Liability
The app/services directory starts with good intentions but often decays into a junk drawer. We'll diagnose the symptoms of a service directory in crisis and explore how patterns like Form Objects, Commands, and Query Objects can restore clarity and maintainability to your Rails app.
Read article →Scaling AI Prompts: A Guide to Building a Prompt Management Engine in Rails
Move beyond hardcoded strings and build a scalable, version-controlled, and testable prompt management system in Rails to manage your AI prompts like professional software.
Read article →The Prompt Engineering Manifesto: From $2,400 Mistakes to Production-Grade AI
A hardcoded prompt typo cost us $2,400 in 72 hours. Here's the engineering discipline, testing strategies, and open-source tool (Promptly) we built to fix it for good.
Read article →Building a Production-Ready AI Agent Foundation in Ruby
Most function calling tutorials show toy examples that break in production. This guide provides the 80% foundation you actually need: a security-hardened, multi-turn agent with complete parameter validation, proper error handling, logging, and timeouts. Copy, customize, and build on it
Read article →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.
Read article →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.
Read article →🚨 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.
Read article →How I approach a slow background job
Background job performance optimization requires systemic analysis beyond simple retries or thread allocation. Effective troubleshooting includes payload size reduction, external call isolation, internal profiling, batching strategies, and queue structure review.
Read article →How I Built a RAG System in Rails Using Nomic Embeddings and OpenAI
RAG doesn’t have to mean heavyweight infrastructure. In this post, I show how I wired up a lean Retrieval-Augmented Generation pipeline inside a Rails app using Nomic for embeddings, PgVector for search, and OpenAI for generation. The result is a flexible system: open-source at the embedding layer, powerful where it counts, and simple enough to extend without vendor lock-in.
Read article →What is Machine Learning?
Machine learning integration in Ruby applications encompasses supervised, unsupervised, and reinforcement learning techniques applied to recommendation systems, fraud detection, and natural language processing. Practical applications demonstrate how ML capabilities enhance traditional Ruby development workflows and create intelligent software solutions.
Read article →Implementing the Saga Design Pattern in Ruby on Rails
Distributed transaction management in microservices utilizes the Saga Design Pattern through choreography and orchestration implementations in Ruby on Rails. Cross-service data consistency, compensating transactions, and failure recovery mechanisms create resilient systems that handle complex business workflows across multiple services.
Read article →Elevating Your Ruby on Rails Apps with Value Objects
Chaotic Rails codebases transform through immutable value objects that encapsulate domain-specific concepts like money, addresses, and calculations. Implementation benefits include improved code readability, increased robustness through immutability, enhanced reusability, and superior error handling for maintainable applications.
Read article →Mastering the decorator pattern in Ruby on Rails
Rails applications gain enhanced functionality through Decorator Pattern implementation using SimpleDelegator, enabling dynamic behavior addition without tight coupling or complex inheritance hierarchies. Modular presentation logic promotes composition over inheritance while maintaining testable, maintainable codebases.
Read article →Autocomplete at Scale - How Tries and Partitioning Can Unlock Blazing-Fast Search in Ruby on Rails
Scalable autocomplete functionality achieving sub-millisecond response times with millions of records employs trie data structures and advanced partitioning strategies in Ruby on Rails. Performance optimization techniques include memory management, database partitioning patterns, and efficient prefix-based search algorithms.
Read article →Procs, Lambdas and Blocks in Ruby on Rails
Rails applications achieve enhanced maintainability and performance through strategic implementation of procs, lambdas, and blocks for collection filtering, view rendering, dynamic sorting, and parameterized logic patterns. Code examples demonstrate practical scenarios including reusable filtering logic and complex data manipulation workflows.
Read article →Look before you leap
Defensive programming principles emphasize state verification before execution to prevent runtime errors and improve application reliability. Ruby implementations demonstrate checking for nil values, empty arrays, hash key existence, and other validation patterns that ensure robust data structure operations.
Read article →Concise Data Extraction with Pattern Matching in Ruby
Ruby's pattern matching syntax introduced in version 2.7 streamlines complex data extraction from structured collections, replacing verbose iterative loops with elegant declarative patterns. Implementation examples demonstrate extracting specific fields from arrays of hashes while improving code readability and maintainability.
Read article →Function arguments, how many are too many?
Function parameter complexity becomes manageable through Ruby patterns including hashes, structs, classes, and builder implementations when traditional argument lists exceed maintainability thresholds. Analysis covers trade-offs between parameter count, function complexity, and code clarity for sustainable software architecture.
Read article →Hash Maps
Hash maps (dictionaries) in Ruby demonstrate efficient key-value pair operations through practical examples including element counting, word frequency analysis, and caching implementations. Performance characteristics and collision handling strategies optimize data retrieval and storage operations in Ruby applications.
Read article →Stacks and Queues
Fundamental data structures stacks (LIFO) and queues (FIFO) receive comprehensive Ruby implementations with complete RSpec test suites, covering practical applications in function call management, task scheduling, and algorithm optimization essential for software engineering interviews and production development work.
Read article →Using Service Objects in Ruby on Rails
Service objects provide an architectural solution to Rails applications struggling with bloated models and controllers by extracting business logic into focused, testable classes and modules. Implementation examples demonstrate both class-based and module-based approaches following single responsibility principles for scalable application architecture.
Read article →