Ruby and Rails Engineering Glossary

This is a working glossary. Every term here reflects how I use it across this site — in guides, checklists and experiment notes. Where a term has multiple meanings depending on context, I've tried to pin down the meaning that matters most for day-to-day Ruby and Rails engineering work.

If you're reading a guide here and hit a term that feels unfamiliar, this is the place to check.

A

ActiveRecord

The ORM layer built into Rails. ActiveRecord maps Ruby classes to database tables, rows to objects and columns to attributes. It handles validations, associations, callbacks, migrations and query generation. Most Rails applications are shaped around ActiveRecord models, for better or worse — understanding where it helps and where it gets in the way is a core Rails engineering skill. See PostgreSQL Indexing for Rails for how database-level decisions interact with ActiveRecord query patterns.

Asset Pipeline

The system Rails uses to compile, concatenate and compress CSS and JavaScript files for production. In older Rails versions this was Sprockets; Rails 7+ introduced Propshaft as a simpler alternative. Getting asset compilation right is a frequent source of deployment issues, especially when switching between major Rails versions.

B

Background Job

A unit of work that runs outside the request/response cycle. Instead of making a user wait while your app sends an email, resizes an image or hits a third-party API, you enqueue a job and a worker process picks it up asynchronously. Sidekiq, GoodJob and Solid Queue are all background job processors for Rails. I cover patterns and trade-offs in Sidekiq Background Jobs Patterns.

Bundler

The dependency manager for Ruby projects. Bundler reads your Gemfile, resolves version constraints across all your gems and writes the result to Gemfile.lock. If you've ever seen "Could not find compatible versions" during a deploy, that's Bundler telling you your dependency graph has a conflict. Treat Gemfile.lock as a critical artifact — always commit it, always deploy with it.

C

Connection Pool

A set of pre-established database connections that your application reuses rather than opening and closing connections per request. In Rails, the connection pool size is configured in database.yml. A common production mistake is setting the pool size lower than the number of threads your app server runs, which causes threads to block waiting for a connection. This matters especially with Puma's multi-threaded model.

CSRF Token

A security token Rails embeds in forms to prevent cross-site request forgery attacks. Rails generates a unique token per session and rejects any POST/PATCH/DELETE request that doesn't include it. If your deploys involve clearing session stores or changing secret keys, CSRF token mismatches will cause form submissions to fail silently for users.

D

Deployment Pipeline

The sequence of steps that take your code from a git push to running in production. A typical pipeline includes running tests, building assets, pushing a container image or syncing files, running migrations and restarting application processes. The specifics vary wildly depending on your infrastructure. I map out common pipeline shapes in Rails Deployment.

Docker

A containerization platform that packages your application and its dependencies into a portable image. For Rails apps, Docker means you can build once and run the same image across development, staging and production. The trade-off is added complexity in your build process, image size management and debugging. Kamal uses Docker images as its deployment unit.

E

EEAT

Experience, Expertise, Authoritativeness and Trustworthiness — a quality framework from Google's search quality guidelines. For a technical site, EEAT means demonstrating real hands-on experience, citing specifics rather than generalities and being honest about what you don't know. I keep this in mind when writing every guide on this site.

G

GC (Garbage Collection)

Ruby's automatic memory management system. The garbage collector identifies objects that are no longer referenced and frees the memory they occupy. Ruby's GC has gone through major improvements — generational GC in Ruby 2.1, incremental marking in 2.2, compaction in 2.7. GC tuning (via environment variables like RUBY_GC_HEAP_INIT_SLOTS) can materially affect request latency in production. See Web Performance for Rails Developers for how this fits into the bigger performance picture.

Gemfile.lock

The file Bundler generates to record the exact versions of every gem (and every transitive dependency) resolved for your project. This is what makes builds reproducible. If two developers or two servers get different behavior, the first thing to check is whether they're running from the same Gemfile.lock.

H

Health Check

An endpoint (typically /up or /health) that returns a simple success response to indicate your application is running and can handle requests. Load balancers, container orchestrators and monitoring systems poll health check endpoints to decide whether to route traffic to a given instance. A good health check verifies database connectivity, not just that the Ruby process is alive.

I

Idempotent Migration

A database migration that can be run multiple times without causing errors or unintended side effects. Standard Rails migrations aren't idempotent by default — running add_column twice will raise an error. Writing idempotent migrations (using if_not_exists checks or conditional logic) is essential for zero-downtime deploy strategies where migrations might run against a database that's already partially migrated.

K

Kamal

A deployment tool from 37signals (the makers of Rails) that deploys Docker containers to bare servers over SSH. Kamal handles container building, registry push, rolling restarts, health checks and load balancer integration. It's the successor to MRSK and is the default deployment tool for new Rails 8 applications. I discuss it in context in Deploy Ruby on Rails on a VPS.

L

Load Balancer

A system that distributes incoming network requests across multiple application servers. In a typical Rails production setup, Nginx or a cloud load balancer sits in front of multiple Puma processes. The load balancer handles SSL termination, connection queuing and health check routing. Getting this layer right is crucial for reliability. See Nginx for Rails Apps for how Nginx fills this role.

M

Middleware

In the Rack ecosystem, middleware is a layer that sits between the web server and your application, processing requests and responses as they pass through. Rails ships with a stack of middleware for logging, session management, cookie handling, CSRF protection and more. You can inspect the stack with rails middleware. Understanding the middleware stack helps when debugging request-level issues that don't seem to originate in your controllers.

Migration

A Ruby class that describes a change to your database schema. Migrations run in order and are tracked by a schema_migrations table so they only run once. Writing good migrations — ones that are reversible, safe to run under load and don't lock tables for extended periods — is a skill that takes time to develop.

N

N+1 Query

A performance antipattern where your code executes one query to load a collection, then one additional query for each item in that collection. If you load 50 posts and each post triggers a query to load its author, that's 51 queries instead of 2. ActiveRecord's includes, preload and eager_load methods are the standard fixes. The Bullet gem can detect N+1 queries automatically during development.

O

ORM (Object-Relational Mapping)

A technique that maps database rows to objects in your programming language. ActiveRecord is Rails' ORM. The benefit is you can work with Ruby objects instead of writing raw SQL for most operations. The cost is that the abstraction can hide what's actually happening at the database level — which is why understanding query plans matters.

P

Puma

The default application server for Rails. Puma is a multi-threaded, multi-process HTTP server that handles concurrent requests efficiently. Key configuration decisions include how many workers (processes) and threads to run, which depends on your server's CPU cores, available memory and whether your app is CPU-bound or I/O-bound. Getting Puma configuration wrong is one of the most common sources of production performance issues.

Q

Query Plan

The execution strategy a database chooses for a given SQL query. You can inspect query plans with EXPLAIN (or EXPLAIN ANALYZE for actual execution statistics) in PostgreSQL. Reading query plans is how you determine whether a query is using an index, doing a sequential scan or performing an expensive sort. This is a critical debugging skill. I cover the fundamentals in PostgreSQL Indexing for Rails.

R

Rack

The interface specification that sits between Ruby web servers and Ruby web frameworks. Rack defines a simple protocol: a Rack application is any Ruby object that responds to call, takes an environment hash and returns a three-element array of status, headers and body. Rails, Sinatra and almost every Ruby web framework are built on Rack. Understanding Rack helps when you need to write custom middleware or debug low-level request handling.

S

Sidekiq

A background job processor that uses Redis as its queue backend and processes jobs in threads. Sidekiq is fast, mature and widely deployed. It has a free tier and commercial Pro/Enterprise tiers with additional reliability features. I walk through production patterns in Sidekiq Background Jobs Patterns.

SSL Termination

The process of decrypting HTTPS traffic at the load balancer or reverse proxy level, then forwarding plain HTTP to your application servers on the internal network. This offloads the CPU cost of encryption from your app servers and centralizes certificate management. Nginx is a common choice for SSL termination in Rails deployments. See Nginx for Rails Apps for configuration specifics.

T

Turbo

Part of the Hotwire framework, Turbo accelerates page navigation by replacing full page loads with partial updates over the wire. Turbo Drive intercepts link clicks and form submissions, Turbo Frames scope updates to a portion of the page and Turbo Streams deliver real-time updates via WebSocket or HTTP responses. Turbo is the default front-end approach in Rails 7+ applications.

Y

YJIT

Yet Another JIT — a just-in-time compiler for Ruby that was merged into CRuby in Ruby 3.1. YJIT compiles frequently-executed Ruby bytecode into native machine code at runtime, producing significant speedups (15–25% on real Rails applications in benchmarks). Enabling YJIT is one of the highest-leverage performance changes you can make if you're on Ruby 3.1+. I discuss the practical implications in Web Performance for Rails Developers.

Z

Zero-Downtime Deploy

A deployment strategy that ensures your application remains available to users throughout the entire deploy process. This typically involves running the new version alongside the old version, routing traffic to healthy instances, running migrations that are backward-compatible and only cutting over once the new version is confirmed healthy. Kamal supports this pattern natively. I cover the mechanics in Deploy Ruby on Rails on a VPS.

This glossary will grow as the site grows. If I use a term in a guide that isn't defined here, that's a gap I want to fix — the contact page is always open.