roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for Rails 8.1 interviews: routing, controllers, Active Record, views and Hotwire, auth and security, jobs, mail, caching, testing, and deploying with Kamal.
724 of 724 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 724 new. 0 cut, outside your plan.
Where the product itself runs on Rails, the framework is the material of the whole technical loop; elsewhere it shrinks to one line in the stack conversation. It shows most in the practical exercise, a take-home or a pairing session on a small Rails app, followed by a talk-through of what you changed. The questions ask what the framework did on your behalf: why `includes` sometimes sends two queries and sometimes one large JOIN, which attribute `permit` kept out of an update, why a form that fails validation must answer with an error status such as 422 before Turbo shows the errors. Experience changes the material more than the depth. Early-career candidates read conventions back: what a resourceful route generates, when a callback fires, what a migration does on rollback. Candidates hired higher get the production version of those subjects and are asked for the cause: a job enqueued from `after_save` that cannot find its record because the transaction has not committed, a Puma server with more threads than database connections timing out under load, an index on a large PostgreSQL table that must be built without blocking writes. From senior level up a design round usually follows, argued in Rails terms: which work leaves the request for a queue, and how a cache key expires.
[Project anatomy and boot](/topics/be-rails-foundations) comes first because Rails is configured by where things live and what they are called: the directory tree, the naming rules, the order initializers run in, and the autoloader that turns a file path into a constant. The command line and [Bundler](/topics/dev-bundler) close that opening. The request is read from the outside in. [Routes](/topics/be-rails-routing-controllers) pick the action, controllers filter, permit and render, and API-only mode shows what a smaller stack leaves out. [Rack](/topics/be-rack) comes last there, as the interface under all of it, once the middleware stack is something you have already met twice. Persistence is the section a practical exercise most often turns on. [Models](/topics/be-rails-active-record) come before associations and both before the query interface, because [eager loading](/topics/be-rails-querying-eager-loading) only makes sense once you know which association a page walks. Adapters, [transactions and locks](/topics/be-rails-databases-transactions), migrations and file storage take the same models down to the database and out to disk. The UI starts server-rendered, with [templates](/topics/be-rails-views-hotwire) and forms, then the asset pipeline, so that [Hotwire](/topics/fe-hotwire) arrives with markup to update and a way for its JavaScript to reach the browser. Active Support and engines are placed after a working app on purpose: concerns and per-request current attributes read as explanations of things the earlier modules already relied on. The plan then turns from building features to protecting them, [logins and permissions](/topics/be-rails-auth) before [hardening](/topics/be-rails-security), and next moves work off the request through [Active Job](/topics/be-rails-active-job-cable), WebSockets and mail. Testing puts Rails's own test types ahead of [RSpec](/topics/dev-rspec) and Minitest as general tools. It ends in production: [caching](/topics/be-rails-caching) at the fragment, data and HTTP layers, [Puma's concurrency settings](/topics/be-rails-deployment-puma), and [Kamal](/topics/cloud-kamal) to ship the image.
A Rails posting names a stack as well as a framework, and this plan teaches the rivals side by side: Devise beside the built-in generator, Solid Queue beside Sidekiq, RSpec beside Minitest. Read the job description, or the team's Gemfile if it is public, before you study, and only skim the gems it does not name. With a week or two, apply the page's filter after your own: raise importance to must know, and give the hours it frees to the request and persistence stretches. Developers arriving from Django, Laravel or Spring already hold the MVC shape; they do best reading by topics, in printed sequence, because their gaps sit at the start, in naming and autoloading. Several years into Rails, let level begin at your own band rather than at junior, and spend the time on what a long-lived app may never have forced on you: lock-safe migrations, row locks, sizing threads against connections, the deploy. Ruby itself is not here. Blocks and procs, the object model and the metaprogramming that makes `has_many` a method call in a class body belong to the [Ruby roadmap](/roadmaps/ruby), and Rails interviews borrow from it freely.
Where the product itself runs on Rails, the framework is the material of the whole technical loop; elsewhere it shrinks to one line in the stack conversation. It shows most in the practical exercise, a take-home or a pairing session on a small Rails app, followed by a talk-through of what you changed. The questions ask what the framework did on your behalf: why includes sometimes sends two queries and sometimes one large JOIN, which attribute permit kept out of an update, why a form that fails validation must answer with an error status such as 422 before Turbo shows the errors.
Experience changes the material more than the depth. Early-career candidates read conventions back: what a resourceful route generates, when a callback fires, what a migration does on rollback. Candidates hired higher get the production version of those subjects and are asked for the cause: a job enqueued from after_save that cannot find its record because the transaction has not committed, a Puma server with more threads than database connections timing out under load, an index on a large PostgreSQL table that must be built without blocking writes. From senior level up a design round usually follows, argued in Rails terms: which work leaves the request for a queue, and how a cache key expires.
Project anatomy and boot comes first because Rails is configured by where things live and what they are called: the directory tree, the naming rules, the order initializers run in, and the autoloader that turns a file path into a constant. The command line and Bundler close that opening.
The request is read from the outside in. Routes pick the action, controllers filter, permit and render, and API-only mode shows what a smaller stack leaves out. Rack comes last there, as the interface under all of it, once the middleware stack is something you have already met twice.
Persistence is the section a practical exercise most often turns on. Models come before associations and both before the query interface, because eager loading only makes sense once you know which association a page walks. Adapters, transactions and locks, migrations and file storage take the same models down to the database and out to disk.
The UI starts server-rendered, with templates and forms, then the asset pipeline, so that Hotwire arrives with markup to update and a way for its JavaScript to reach the browser. Active Support and engines are placed after a working app on purpose: concerns and per-request current attributes read as explanations of things the earlier modules already relied on.
The plan then turns from building features to protecting them, logins and permissions before hardening, and next moves work off the request through Active Job, WebSockets and mail. Testing puts Rails's own test types ahead of RSpec and Minitest as general tools. It ends in production: caching at the fragment, data and HTTP layers, Puma's concurrency settings, and Kamal to ship the image.
A Rails posting names a stack as well as a framework, and this plan teaches the rivals side by side: Devise beside the built-in generator, Solid Queue beside Sidekiq, RSpec beside Minitest. Read the job description, or the team's Gemfile if it is public, before you study, and only skim the gems it does not name. With a week or two, apply the page's filter after your own: raise importance to must know, and give the hours it frees to the request and persistence stretches.
Developers arriving from Django, Laravel or Spring already hold the MVC shape; they do best reading by topics, in printed sequence, because their gaps sit at the start, in naming and autoloading. Several years into Rails, let level begin at your own band rather than at junior, and spend the time on what a long-lived app may never have forced on you: lock-safe migrations, row locks, sizing threads against connections, the deploy.
Ruby itself is not here. Blocks and procs, the object model and the metaprogramming that makes has_many a method call in a class body belong to the Ruby roadmap, and Rails interviews borrow from it freely.