Skip to main content

Learning path

Ruby on Rails learning path: everything to study, topic by topic

Comprehensive Ruby on Rails assessment covering Ruby language fundamentals, Rails conventions and architecture, Active Record and database modeling, controllers and views, authentication and authorization, background jobs, caching, testing, performance optimization, deployment, and security best practices.

Short answer

To learn Ruby on Rails, work through 6 modules and 24 topics in the order they build on each other. It starts with Ruby Fundamentals, then moves on to Rails Basics and Models & Database. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
24
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · Ruby Fundamentals4 topics
  • Ruby Syntax & Basics

    Variables (local, instance, class, global), data types (String, Integer, Float, Symbol, NilClass), string interpolation, conditional expressions, loops, iterators, and method definitions

    Objectives

    • Write basic Ruby code with proper syntax and conventions
    • Understand Ruby's dynamic typing and variable scoping rules

    Key concepts

    • variable scopes
    • data types
    • string interpolation
    • symbols vs strings
    • conditionals (if/unless/case)
    • iterators (each, map, select)
    • method definitions
    • implicit return
  • Data Structures

    Arrays, Hashes, Sets, Ranges, Structs, and OpenStruct. Common enumerable methods, hash manipulation, array slicing, and collection pipelines

    Objectives

    • Use Ruby collections effectively with enumerable methods
    • Choose the right data structure for different use cases

    Key concepts

    • arrays and common methods
    • hashes and symbol keys
    • ranges
    • Enumerable module
    • map/select/reduce
    • Struct vs OpenStruct
    • array slicing
    • hash default values
  • Blocks, Procs & Lambdas

    Block syntax (do..end and {}), yield keyword, Proc objects, lambda literals, closures, method objects, and the & operator for block-to-proc conversion

    Objectives

    • Explain the differences between blocks, procs, and lambdas
    • Use blocks and yield to create flexible methods

    Key concepts

    • block syntax
    • yield keyword
    • Proc.new
    • lambda vs proc
    • closures
    • & operator
    • method(:name)
    • block_given?
  • Object-Oriented Ruby

    Classes, modules, inheritance, mixins, method lookup chain, attr_accessor/reader/writer, access control (public/private/protected), duck typing, and metaprogramming basics

    Objectives

    • Design Ruby classes with proper encapsulation and inheritance
    • Understand Ruby's method lookup chain and module mixins

    Key concepts

    • class definition
    • modules and mixins
    • inheritance
    • method lookup chain
    • attr_accessor
    • access control
    • duck typing
    • method_missing
2 · Rails Basics4 topics
  • Rails Conventions & Architecture

    Convention over configuration, MVC architecture, directory structure, Gemfile and Bundler, Rails environments, autoloading with Zeitwerk, and the Rails philosophy

    Objectives

    • Explain Rails conventions and the MVC architecture
    • Navigate a Rails project structure confidently

    Key concepts

    • convention over configuration
    • MVC pattern
    • directory structure
    • Gemfile and Bundler
    • Rails environments
    • Zeitwerk autoloading
    • DRY principle
    • Rails console
  • Routing

    RESTful routes, resources macro, nested resources, member and collection routes, named routes, route constraints, namespace and scope, and route helpers

    Objectives

    • Define RESTful routes using the resources macro
    • Use nested resources and route constraints appropriately

    Key concepts

    • resources macro
    • RESTful routes
    • nested resources
    • member and collection
    • named routes
    • route constraints
    • namespace vs scope
    • root route
  • Generators & Scaffolding

    Rails generators (model, controller, migration, scaffold), customizing generators, scaffold anatomy, destroying generated files, and when to avoid scaffolding

    Objectives

    • Use Rails generators to bootstrap application components
    • Understand what each generator produces and when to use it

    Key concepts

    • rails generate command
    • model generator
    • controller generator
    • scaffold generator
    • migration generator
    • rails destroy
    • custom generators
    • generator templates
  • Configuration & Environments

    Application configuration, environment-specific settings, credentials and secrets, initializers, config/application.rb, database.yml, and environment variables

    Objectives

    • Configure a Rails application for different environments
    • Manage secrets and credentials securely

    Key concepts

    • config/application.rb
    • environment files
    • credentials (rails credentials:edit)
    • database.yml
    • initializers
    • environment variables
    • config_for
    • custom configuration
3 · Models & Database4 topics
  • Active Record Fundamentals

    Active Record pattern, CRUD operations, query interface (where, find, find_by, order, limit), scopes, pluck, select, and the Arel query builder

    Objectives

    • Perform CRUD operations using Active Record
    • Build efficient queries with scopes and the query interface

    Key concepts

    • Active Record pattern
    • CRUD operations
    • where and find_by
    • scopes
    • chaining queries
    • pluck and select
    • Arel basics
    • raw SQL with find_by_sql
  • Migrations

    Database migrations, schema changes, reversible migrations, column types, indexes, foreign keys, data migrations, and schema.rb vs structure.sql

    Objectives

    • Write safe and reversible database migrations
    • Understand when to use schema.rb vs structure.sql

    Key concepts

    • create_table
    • add_column/remove_column
    • add_index
    • add_foreign_key
    • reversible migrations
    • change vs up/down
    • schema.rb
    • data migrations
  • Associations

    has_one, has_many, belongs_to, has_many :through, has_and_belongs_to_many, polymorphic associations, self-joins, inverse_of, dependent options, and eager loading

    Objectives

    • Model complex domain relationships with Active Record associations
    • Avoid N+1 queries using eager loading strategies

    Key concepts

    • belongs_to and has_many
    • has_many :through
    • polymorphic associations
    • self-referential joins
    • inverse_of
    • dependent: :destroy
    • eager loading (includes)
    • counter_cache
  • Validations & Callbacks

    Built-in validations (presence, uniqueness, format, numericality), custom validators, conditional validations, lifecycle callbacks (before_save, after_create), and callback pitfalls

    Objectives

    • Implement model validations for data integrity
    • Use callbacks judiciously while understanding their risks

    Key concepts

    • presence validation
    • uniqueness validation
    • custom validators
    • conditional validations
    • before_save callback
    • after_create callback
    • callback ordering
    • callback pitfalls
4 · Controllers & Views4 topics
  • Controllers & Actions

    RESTful actions, strong parameters, before_action filters, respond_to, flash messages, redirects, rendering, and controller concerns

    Objectives

    • Implement RESTful controller actions with proper parameter handling
    • Use filters and concerns to keep controllers DRY

    Key concepts

    • RESTful actions (index/show/new/create/edit/update/destroy)
    • strong parameters
    • before_action
    • respond_to
    • flash messages
    • redirect_to vs render
    • controller concerns
    • rescue_from
  • Views & Templates

    ERB syntax, layouts, partials, content_for and yield, view helpers, Turbo Frames and Streams (Hotwire), and asset pipeline vs Propshaft

    Objectives

    • Build dynamic views using ERB templates and partials
    • Understand Hotwire and modern Rails frontend approaches

    Key concepts

    • ERB syntax (<%= %> vs <% %>)
    • layouts and yield
    • partials and locals
    • content_for
    • view helpers
    • Turbo Frames
    • Turbo Streams
    • Propshaft
  • Forms & Helpers

    form_with helper, form builders, nested attributes (accepts_nested_attributes_for), CSRF protection, file uploads with Active Storage, and custom form objects

    Objectives

    • Build forms with proper security and nested attribute handling
    • Implement file uploads using Active Storage

    Key concepts

    • form_with
    • form builders
    • nested attributes
    • CSRF tokens
    • Active Storage
    • file uploads
    • custom form objects
    • strong parameters for nested
  • API Mode & Serialization

    Rails API-only applications, JSON serialization (jbuilder, ActiveModelSerializers, Alba), API versioning, pagination, rate limiting, and CORS configuration

    Objectives

    • Build API-only Rails applications with proper serialization
    • Implement versioning, pagination, and rate limiting for production APIs

    Key concepts

    • API-only mode
    • JSON serialization
    • jbuilder
    • API versioning
    • pagination (Kaminari/Pagy)
    • rate limiting
    • CORS configuration
    • API authentication tokens
5 · Advanced Rails4 topics
  • Authentication

    has_secure_password, Devise gem, OmniAuth for OAuth, JWT authentication, session management, remember tokens, password reset flows, and multi-factor authentication

    Objectives

    • Implement authentication with Devise or from scratch
    • Design secure session management and token-based auth

    Key concepts

    • has_secure_password
    • Devise gem
    • OmniAuth
    • JWT tokens
    • session management
    • remember me tokens
    • password reset flow
    • multi-factor authentication
  • Authorization

    Pundit gem, CanCanCan gem, role-based access control, policy objects, resource-based authorization, admin panels, and multi-tenancy authorization

    Objectives

    • Implement fine-grained authorization with Pundit or CanCanCan
    • Design role-based and resource-based access control systems

    Key concepts

    • Pundit policies
    • CanCanCan abilities
    • role-based access
    • policy objects
    • resource scoping
    • admin authorization
    • multi-tenancy
    • action-based permissions
  • Background Jobs

    Active Job framework, Sidekiq adapter, job queues and priorities, retry strategies, scheduled jobs, idempotency, and job monitoring

    Objectives

    • Design reliable background job processing with Sidekiq
    • Implement idempotent jobs with proper retry and error handling

    Key concepts

    • Active Job interface
    • Sidekiq adapter
    • job queues
    • retry strategies
    • scheduled jobs (sidekiq-cron)
    • idempotent jobs
    • job monitoring
    • dead letter queues
  • Caching Strategies

    Fragment caching, Russian doll caching, low-level caching (Rails.cache), HTTP caching (ETags, Last-Modified), cache stores (Redis, Memcached), and cache invalidation

    Objectives

    • Implement multi-level caching strategies in Rails
    • Design effective cache invalidation policies

    Key concepts

    • fragment caching
    • Russian doll caching
    • Rails.cache (low-level)
    • HTTP caching (ETags)
    • cache stores (Redis)
    • cache invalidation
    • cache key generation
    • conditional GET
6 · Production Rails4 topics
  • Testing

    RSpec framework, factory_bot, request specs, model specs, system specs with Capybara, mocking and stubbing, test coverage, and TDD workflow in Rails

    Objectives

    • Write comprehensive tests using RSpec and factory_bot
    • Apply TDD practices in Rails development

    Key concepts

    • RSpec syntax (describe/context/it)
    • factory_bot factories
    • request specs
    • model specs
    • system specs (Capybara)
    • mocking and stubbing
    • shared examples
    • test coverage (SimpleCov)
  • Performance Optimization

    N+1 query detection (Bullet gem), database indexing, query optimization, Rack middleware, memory profiling, connection pooling, and horizontal scaling

    Objectives

    • Identify and resolve performance bottlenecks in Rails applications
    • Optimize database queries and application memory usage

    Key concepts

    • N+1 query detection
    • database indexing strategies
    • query optimization (EXPLAIN)
    • Rack middleware
    • memory profiling
    • connection pooling
    • database sharding
    • CDN and asset optimization
  • Deployment & DevOps

    Capistrano deployment, Docker containerization, CI/CD pipelines, Puma configuration, Kamal deployment, database backup strategies, and zero-downtime deploys

    Objectives

    • Deploy Rails applications with zero-downtime strategies
    • Set up CI/CD pipelines and containerized deployments

    Key concepts

    • Capistrano deployment
    • Docker for Rails
    • CI/CD pipelines
    • Puma configuration
    • Kamal deployment
    • database backups
    • zero-downtime deploys
    • log aggregation
  • Security

    CSRF protection, SQL injection prevention, XSS mitigation, Content Security Policy, mass assignment protection, secure headers, dependency auditing (bundler-audit), and OWASP top 10

    Objectives

    • Harden Rails applications against common security vulnerabilities
    • Implement defense-in-depth security strategies

    Key concepts

    • CSRF protection
    • SQL injection prevention
    • XSS mitigation
    • Content Security Policy
    • mass assignment protection
    • secure headers
    • bundler-audit
    • OWASP top 10 for Rails

Levels: Junior, Mid, and Senior

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying Ruby on Rails?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying Ruby on Rails?

Start with Ruby Fundamentals: Ruby Syntax & Basics, Data Structures, and Blocks, Procs & Lambdas. The map orders topics by what they depend on, so each one prepares the next.

How long does a full Ruby on Rails assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.