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.
architecture
YouTube runs the biggest recommendation feed on the planet, and it does not win with rules. See how its homepage ranks on satisfaction instead of clicks, learns per user, and trusts reactions, then how to build the same ideas into your own app with Ruby and SQL.
software-design
Every engineer learns DRY in their first year: don't repeat yourself, extract the common code, keep
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.
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.
AI agent architecture comes down to three strategies: single agent, sequential, and parallel. When one big prompt loses the plot, how sequential chains buy reliability, where parallel agents crush latency, and the pitfalls of each before you commit.
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::Box in Ruby 4.0 isolates monkey patches so one gem's core-class override stops breaking the rest of your process. How the isolation works, what problems with global state it ends, and the limitations to weigh before you rely on it.
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.
Event sourcing meets GDPR the moment a user asks to be forgotten and your log is append-only. Crypto-shredding is the elegant answer: encrypt personal data per user, delete the key, and design system boundaries so backups and read models forget too.
Business archetypes prove your 'unique' domain is usually a store selling something unusual. Map complex requirements onto universal building blocks: product catalogue, orders, entitlements, inventory for services, party and billing, and stop reinventing the wheel.
Pseudo-modularity looks like clean folders and rots underneath: a change in Products breaks Inventory tests and blocks three teams. Why noun-driven modules and a shared database create facade modularity, and what real module boundaries look like.
A distributed monolith is what you get when microservice boundaries are drawn wrong. How to design autonomous modules in three phases: business analysis for boundaries, tight communication contracts, and deployment decisions driven by real architectural drivers.
Messaging is not a default answer. When a business flow is synchronous, queues add complexity without value and message ordering becomes your biggest pitfall. How to recognise the cases where a simple synchronous call keeps the system easier to build and debug.
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.
Event-driven systems lose, duplicate and reorder messages unless you design against it. Practical patterns for reliable delivery: the outbox pattern, change data capture straight from the database, handling order and duplicates, and how to test it all.
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.