When a Rails or LMS Platform Becomes Hard to Change
A practical way for small education and SaaS teams to diagnose Rails or LMS platform friction and decide whether a rewrite is actually justified.
Tag: performance
Testing Small Local LLMs on Modest Hardware: A Portable Workflow
A repeatable way to download, serve, benchmark, and choose small GGUF models for Hermes and coding-agent work across different CPU and memory budgets.
Rails Performance from the Metal Up: A Field Guide
A practical Rails performance field guide for diagnosing CPU, IO, GVL, GC, memory, Puma, and container-runtime bottlenecks before choosing a fix.
Postgres conflict with recovery: why replicas cancel queries
A PostgreSQL replica cancels long queries with conflict with recovery errors during VACUUM replication, and hot_standby_feedback fixes it without downtime.
Production Ruby Debugging: A Progressive Escalation Guide
A progressive escalation guide to debugging Ruby applications in Kubernetes production without restarting: rbspy, kubectl debug, signals, rbtrace, and gdb.
Token Efficiency for AI Coding Agents in 2026
Six practical techniques for cutting token spend in AI coding agents, from skeleton indexes to symbol-level retrieval and semantic caching.
Polymorphic Indexes in MySQL: Type-First or ID-First?
A practical comparison of [type, id] versus [id, type] composite index order for polymorphic associations in Rails and MySQL, and how to choose.
Redis Cleanup and Memory Management in Kubernetes
A production-tested guide to keeping Redis healthy in Kubernetes: memory control, safe cleanup patterns, Sidekiq pitfalls, backups, and troubleshooting.
Choosing a Website Stack for a 1C1G Server
A comparison of static sites, WordPress, headless CMS, and Node.js CMS options for a 1 vCPU, 1GB RAM server, by memory use and stability.
Optimizing a 1C1G Ubuntu Cloud Server
A production-tested checklist for making a 1 vCPU, 1GB RAM Ubuntu server stable: swap, kernel tuning, service removal, and MySQL/PHP-FPM limits.
Transactions, touch, and async rollups for derived data in Rails
Keeping counters and summaries accurate in Rails without slowing down writes means separating core data in a transaction from derived data updated after commit.
load_async in Rails 8: loading associations concurrently
Rails 8's load_async runs association queries concurrently instead of one after another, and getting it right means sizing your connection pool correctly.
Rails 8.1.1 + connection_pool 3.x: RedisCacheStore boot crash
A keyword-argument mismatch between Ruby 3.4 and connection_pool 3.x breaks RedisCacheStore at Rails 8.1.1 boot, fixed with a patch loaded before initializers run.
From Shared Database to APIs: Taming the Performance Hit
How to cut the latency cost of moving from a shared database to an API-driven architecture, using caching, request aggregation, and async writes.
From 499 to 200: Fixing Nginx Timeouts in a Rails API
How Puma worker timeouts and Nginx 499 errors expose slow Rails requests, and how to fix them with aligned timeouts, background jobs, and caching.
Optimizing Android Builds in GitHub Actions
Android builds in GitHub Actions run 10-30 minutes unoptimized; layered Gradle and Yarn caching plus scoped environment secrets get that down to a few minutes.
JavaScript Engines in React Native: JSC vs. Hermes
React Native's default JS engine moved from JSC to Hermes for faster startup and lower memory use, and here is how to control which one your build uses.
Responsive Images: Serving the Right Size for Every Screen
Comparing srcset and picture, the native HTML approach to responsive images, against JavaScript solutions like jQuery Foundation Interchange.
Speeding Up Docker: Fixing Slow Host-to-Container File Sync
Bind-mounted host directories make Docker Desktop file access painfully slow on macOS and Windows, and this covers volumes, docker-sync, Mutagen, and WSL 2 fixes.
Enabling Gzip and Brotli Compression on Google Cloud CDN
Google Cloud CDN can compress responses with Brotli or Gzip automatically, covering the compressionMode setting, cache invalidation, and verifying it works.
Web Workers vs Service Workers: What Each One Is For
The difference between Web Workers and Service Workers: one offloads CPU work, the other intercepts network requests, and most apps eventually need both.
Ruby Ractor vs the GVL: When You Get Real Parallelism
How Ruby's Global VM Lock limits threaded CPU-bound code, and how Ractor bypasses it entirely by trading shared memory for message passing.
PostgreSQL JSONB vs Linking Tables for Relationships
Comparing PostgreSQL jsonb columns against a traditional linking table for modeling course prerequisites, and where a hybrid of both makes more sense.
Is Your Endpoint I/O Bound or CPU Bound?
How to tell whether a slow endpoint is I/O bound or CPU bound, using system monitors, timing, and cProfile, and why the fix differs for each.
Idempotent Rails Requests with a Redis Semaphore Lock
How to stop duplicate Rails requests from creating the same record twice, using a Redis-backed semaphore lock instead of chasing a race condition.
Deadlocks in MySQL and PostgreSQL: Foreign Keys vs Performance
How deadlocks form in MySQL and PostgreSQL under concurrent updates, and the trade-off between foreign key integrity and write throughput.
Retry Strategies in Ruby: Exceptions vs. Conditional Checks
Comparing Ruby retry patterns, exception-based retry, conditional checks, and exponential backoff, and when each keeps performance acceptable.
API Design for Time Slot Replacement in Booking Systems
How to design a booking API that replaces regular time slots with alternatives, using server-side merging, cache versioning, and idempotency keys.
When AWS Lambda Makes Sense for a Single API Endpoint
A decision framework for when AWS Lambda fits a single API endpoint, and when a container or dedicated server is the better call instead.
Ordering by an Associated Column Without Breaking includes
Why ordering ActiveRecord results by an associated table's column breaks with includes, and how references, Arel, and left_joins fix it for good.
N+1 Queries in Rails: What Silently Breaks `includes`
How ActiveRecord's includes prevents N+1 queries in Rails, and the common mistakes with order, filtering, and pluck that silently break it.
Ruby readability vs performance: filter_map and a single loop
Ruby's filter_map cuts a multi-pass select/map/uniq chain to one pass, and a plain each loop goes further still when performance actually matters.
Rufus Scheduler: How Its Main Loop Actually Works
How rufus-scheduler's single-threaded main loop triggers, times out, and runs jobs, and where a timer-based rewrite would scale better.
Materialized Views: Speeding Up Queries with a Tradeoff
Materialized views cache expensive PostgreSQL queries as physical tables, trading storage and refresh cost for fast reads, plus how pgpool fits in.
Ruby's GVL vs Ractor: What Actually Runs in Parallel
Ruby's Global VM Lock serializes threads for CPU-bound work, and Ractor works around it with isolated memory, benchmarked here against threads and processes.
Speeding Up Nested JSON Serialization in Rails
Caching, the Oj gem, eager loading, background jobs, and load_async each cut serialization time for deeply nested Rails associations like classrooms and scores.
Rails N+1 Queries: joins vs preload vs eager_load vs includes
What joins, preload, eager_load, and includes actually do in ActiveRecord, shown with real SQL logs, plus the chained calls that quietly bring the N+1 back.
Redis Memory Spikes: Tracking Down a Runaway Sidekiq Queue
How I traced a Redis memory jump from 130MB to 800MB back to an unthrottled Sidekiq integration, and the maxmemory, eviction, and unique-job fixes that followed.
Fragment Caching a Large List That Changes Constantly
How splitting static and dynamic fields, granular fragment caching, and incremental loading keep a large, frequently updated list fast without stale data.
Redis in Ruby on Rails: Cache Server and Job Queue
Redis serves two very different roles in a Rails app, a disposable read cache and a durable job queue, and conflating the two causes real outages.