ruby-on-rails
A modular monolith in Rails buys you one thing: a checked constant dependency graph. Packwerk 3.3 and Rails engines run against a real app show where the boundary holds, where a single method argument walks straight through it, and which of your problems stay exactly as they were.
docker
Shrink a Rails Docker image from 1 GB to under 150 MB in seven ordered steps: smaller base image, .dockerignore, multi-stage builds, layer ordering, distroless with its honest caveat, and digest pinning. Every step is measurable the same afternoon.
ruby
AI writes confident Rails code that quietly breaks production standards. Build a quality workflow that catches it: Lefthook gates, Strong Migrations as a hard line, N+1 detection with Prosopite, database checks in layers, and CI that mirrors local hooks.
Removing a Rails database column can crash old processes mid-deploy. This walkthrough shows the safe order: ignored_columns first, migration later, plus how to handle columns that still hold data and what the schema cache does behind your back.
HTTP caching refresher for engineers: how freshness, revalidation, Vary and Cache-Control really interact, why stale responses can still be useful, what reload actually does, and the boring headers that keep private content out of shared caches.
Rails partials feel free until a page renders hundreds of them. Benchmarks of five rendering strategies (inline ERB, partial loops, collection rendering and more) show which is fastest, why the helper trick backfires, and a practical rule for when to optimize views.
UUIDv7 arrives in PostgreSQL 18 as a built-in uuidv7() function. See what it changes in practice: friendlier indexes than UUIDv4, simpler Rails migrations, a schema example, and the security caveat that time-ordered does not mean secret.
Auditing a legacy Rails codebase starts with one question: what is the team afraid to change? A practical method for finding real hotspots, building a small audit ledger, using tools and AI without drowning in output, and delivering one page that people act on.
Structured output from Ollama takes more than JSON mode. Learn the reliable pattern for a Rails app: shape the input, constrain output with JSON Schema, parse defensively, and retry with feedback so a local LLM survives production instead of just a demo.
SQLite in production works better than its toy reputation, but only if you know the traps: why WAL mode is non-negotiable, how blue-green deployments break your setup, missing ILIKE, quirky JSON types, and what you honestly gain in return.
Structured logging lands in Rails 8.1 with the Rails.event API. How the Structured Event Reporter replaces regex-parsed log lines with JSON events, plus tags, context, schemas, debug mode, and how to subscribe and test events in your own app.
Ruby modules often beat classes for service objects: why a shell class like PasswordResetInitiator is procedural code in disguise, using a module as a toolbox, mixins instead of artificial inheritance, and Data objects for tidy parameters.
Ruby 4.0 marks the language's 30th birthday with maturity instead of revolution: saner syntax for multiline conditions, faster boot with fewer requires, a maturing Ractor story, hidden performance gems, and protection against command injection.
Sidekiq capsules let you give each queue its own concurrency, so photo processing stops clogging urgent jobs and API calls stay under rate limits. A three-step setup: configure the capsule, assign the job, and call it, with configuration examples.
Rails performance starts with understanding the GVL: why only one thread runs Ruby code at a time, how that throttles CPU-bound apps, throughput vs latency, choosing a server, offloading to background jobs, and how to instrument and measure before optimising.
PostgreSQL lock timeouts strike during long migrations and complex transactions. How lock_timeout and statement_timeout actually work, quick fixes at the database role level, managing timeouts in Rails migrations, and global protection with StrongMigrations.
after_all_transactions_commit solves a classic Rails race condition: a background job looking for a record that is not committed yet. How the new ActiveRecord callback works inside and outside transaction blocks, and when to reach for it.
Slow SQL queries in Rails can be caught in development, before they become production fires. Using ActiveSupport::Notifications and the sql.active_record event, you build a small performance guard that logs every query above a time threshold straight to your console.
Idle PostgreSQL connections eat memory and can hit the max_connections limit, blocking your app. How to find old sessions in pg_stat_activity, close them safely with pg_terminate_backend, and automate the cleanup so hanging connections never pile up again.
AASM adds complexity most Rails apps don't need. How to replace the state machine gem with Rails 7.1+ enum, validations, and small service objects: a project management example with forms, translations, unit tests, multiple enums, and state history tracking.
Deprecation lets you remove old Rails code without breaking teammates' apps overnight. A practical look at ActiveSupport::Deprecation: why sudden deletes hurt, how to warn about methods scheduled for removal, and how to phase out code in a civilized way.
Sending large files through Rails wastes memory and blocks app workers. X-Sendfile hands the transfer to NGINX while Rails keeps authentication and caching: server configuration, cache headers, testing in development, other HTTP servers, and a complete example.
ActiveJob::Continuable lets long-running Rails jobs survive restarts: split work into steps, track progress with cursors and checkpoints, and resume exactly where the job stopped. Covers error handling, queue adapter support, and a practical example.