Free through lesson 3

Ruby & Ruby on Rails for Beginners

From Ruby syntax to Rails MVC, Active Record, forms and authentication, testing with RSpec, Hotwire, and deploying with Docker and Kamal. In 50 lessons, you'll get to the point where you can build and launch a members-only blog with login. All code, command output, and test results were actually run on Ruby 3.4.10 and Rails 8.1.3.1.

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are split into 7 chapters. We recommend going in order from chapter 1, but feel free to jump to whatever interests you. * Ruby and Rails can't run in the browser, so try things with the Ruby 3.4 you install in lesson 2 and the Rails 8.1 app you create in lesson 9.

Chapter 1 — Ruby Syntax (lessons 1–8)

Before getting into Rails, you'll learn to write Ruby itself. You'll cover variables and methods, arrays and hashes, blocks, classes and modules, and exceptions, running everything with the ruby command as you go.

1

What Is Ruby? (Everything Is an Object)

A first look at Ruby, the foundation of Rails. Learn two quirks: even numbers have methods, and the last evaluated expression is the return value.

Free
2

Setting Up (rbenv, gem, Bundler)

Pin the Ruby version per project. The difference between gem and Bundler, what Gemfile and Gemfile.lock do, and why you use bundle exec.

Free
3

Variables and Methods (Passing Arguments)

Local variables, instance variables, and constants. Default arguments, keyword arguments, variable-length arguments, and the convention for method names ending in ? and !.

Free
4

Conditionals and Loops (unless and each)

How to write if, unless, and case/in, and why you loop with each or times instead of for. Plus modifier if and guard clauses for exiting early.

🔒 Basic
5

Arrays and Hashes

Creating arrays and getting values out, symbol keys in hashes, and digging into nested data. Plus how Rails params is a hash.

🔒 Basic
6

Blocks and Enumerable (map, select, reduce)

Dig into blocks, the reason Rails code is so short. When to use do…end vs { }, how map differs from each, and what &:name really is.

🔒 Basic
7

Classes and Modules (Inheritance and Mixins)

attr_accessor, initialize, inheritance, and super. Plus how mixins, which include a module to blend in features, are exactly what Rails concerns are.

🔒 Basic
8

Exceptions and Gems (rescue and Bundler)

How to write begin/rescue/ensure and raise. Why you define your own exception classes, and the steps from adding a gem to the Gemfile to running bundle install.

🔒 Basic

Chapter 2 — Getting Rails Running (lessons 9–15)

You'll create an app with rails new and follow how the three pieces, routing, controllers, and views, connect. By the end of this chapter, you'll be able to add a URL and show your own page.

9

rails new and the Directory Structure

Create an app and map out what goes in each folder. Plus the commands in bin/ and the /up endpoint that works from the start.

🔒 Basic
10

MVC and the Request Flow

Follow one line from hitting a URL to getting HTML back. How the router, controller, and view divide the work, and how to read the logs.

🔒 Basic
11

Routing (routes.rb and Named Routes)

How to write get, root, dynamic segments, and resources, and how to read bin/rails routes. Plus why you use _path helpers.

🔒 Basic
12

Controllers and Actions

How to read params, the difference between render and redirect_to, shared logic with before_action, and returning status codes.

🔒 Basic
13

Writing Views with ERB

The difference between <%= %> and <% %>, automatic escaping and raw, conditionals and loops, and view helpers like link_to.

🔒 Basic
14

Layouts and Partials

Build a frame shared by every page with layout and yield, swap the title with content_for, and extract partials starting with _ using locals.

🔒 Basic
15

[Practice] From Static Pages to Dynamic Pages

Tie the last six lessons together. Rebuild four pages (home, list, detail, search) all the way from routing to partials.

🔒 Basic

Chapter 3 — Active Record (lessons 16–23)

You'll create tables with migrations and read and write them through models. You'll work through validations, associations, and scopes, and finish by spotting N+1 queries in the logs and fixing them.

16

Migrations and the Schema

Create tables in Ruby instead of SQL. The files rails generate model creates, db:migrate and db:rollback, and why schema.rb is the source of truth.

🔒 Basic
17

Models and CRUD (Create, Read, Update, Delete)

The difference between new and create, what save returns, update and destroy. Use db/seeds.rb to get back to the same state as often as you like.

🔒 Basic
18

Writing Queries (where, order, limit)

Building search conditions, and the fact that Active Record is lazy. Check the SQL with to_sql, and cut wasteful loading with pluck and exists?.

🔒 Basic
19

Validations

Check values before saving. presence, length, uniqueness, numericality, and how to read errors. What's happening when save returns false.

🔒 Basic
20

Associations (belongs_to and has_many)

Connect foreign keys and model associations. Categories and posts, posts and comments. What gets left behind if you forget dependent.

🔒 Basic
21

Many-to-Many (has_many through)

Represent relationships where "both sides are many," like posts and tags, with a join table. How to write through, and reassigning with <<.

🔒 Basic
22

Scopes and Callbacks

Name common conditions with scope, why to avoid default_scope, and hooking into saving with before_save and after_create.

🔒 Basic
23

N+1 Queries and Indexes

Measure the two main reasons list pages get slow. Count the SQL queries in the log and reduce them with includes and indexes.

🔒 Basic

Chapter 4 — Forms and Authentication (lessons 24–31)

You'll accept input with form_with and use Strong Parameters to limit which fields are accepted. You'll write authentication by hand with has_secure_password, then replace it with Devise, and finish by making sure users can edit only their own posts.

24

Forms (form_with)

Build a page that accepts input. Create seven URLs with resources, see the HTML and CSRF token form_with generates, and send users back to the form on errors.

🔒 Basic
25

Strong Parameters

Why you must not pass params straight through. What require and permit mean, permitting nested values and arrays, and the error you get if you forget.

🔒 Basic
26

Completing CRUD

Write all seven actions. Consolidate record loading with before_action, and add edit, update, destroy, and a delete confirmation.

🔒 Basic
27

Flash Messages and Redirects (PRG)

Why you redirect after saving, notice and alert, the difference between flash and flash.now, and the pattern that prevents double submission.

🔒 Basic
28

Writing Authentication by Hand (has_secure_password)

Build your own system that never stores passwords in plain text. bcrypt, authenticate, and what to put in the session.

🔒 Basic
29

Adding Authentication with Devise

Switch to the go-to gem. The config devise:install generates, choosing modules, the eight routes it adds, and current_user.

🔒 Basic
30

Authorization (Requiring Login and Checking Ownership)

Authentication vs authorization. Require login with before_action, and let users edit only their own posts. Why you must not accept user_id from params.

🔒 Basic
31

[Practice] Managing Posts per User

Tie everything so far together. Run through login, creating posts, commenting, and owner-only editing to confirm it all works.

🔒 Basic

Chapter 5 — Testing and Quality (lessons 32–38)

So you notice right away when something breaks, you'll run both Minitest and RSpec. You'll create test data with FactoryBot, check whole pages with request specs, and let RuboCop and Brakeman review your style and security holes for you.

32

Writing Tests with Minitest (rails test)

Run the tests that come with Rails. Fixing fixtures, the kinds of assertions, and how to read failures.

🔒 Basic
33

Adding RSpec

Move to RSpec, common in the workplace. The files rspec:install creates, the roles of describe / context / it, and how to read the output.

🔒 Basic
34

Model Specs and Matchers

Common matchers, let vs before, subject, and shared_examples. Writing tests that read like documentation.

🔒 Basic
35

Creating Test Data with FactoryBot

Instead of fixtures, create just the data you need on the spot. build and create, associations, traits, and sequences.

🔒 Basic
36

Request Specs

Test whole pages. Writing get / post, checking the status and body, and how to set up a logged-in state with Devise.

🔒 Basic
37

System Specs, and What to Test

Write browser interactions. Run them fast with the rack_test driver, and decide what to test at which layer.

🔒 Basic
38

RuboCop and Brakeman

Let tools check your style and security holes. rubocop-rails-omakase settings, autocorrect, security scans, and gem vulnerability checks.

🔒 Basic

Chapter 6 — Real-World Features (lessons 39–45)

You'll use Hotwire to update parts of the page with almost no JavaScript, and Active Job to push heavy work into the background. You'll also cover file uploads, email, and translating your app into Japanese: the things that always come up in real work.

39

Hotwire and Turbo Drive

How pages get faster with almost no JavaScript. What Turbo Drive intercepts, plus data-turbo-method and 303.

🔒 Basic
40

Turbo Frames

Replace just part of a page. How turbo_frame_tag frames match up, how to break out of a frame, and lazy loading.

🔒 Basic
41

Turbo Streams

Update several places with one response. When to use append, replace, and remove, and how to write .turbo_stream.erb.

🔒 Basic
42

Stimulus

Where to put JavaScript when you really need it. Just learn four things: controller, target, action, and value.

🔒 Basic
43

Deferring Work with Active Job

Separate slow work from the request. What perform_later means, what you can pass as arguments, and retrying on failure.

🔒 Basic
44

File Uploads (Active Storage)

Attach images to posts. has_one_attached, configuring where files are stored, checking attached?, and handling dangerous file names.

🔒 Basic
45

Translating the App into Japanese (I18n) and Email

Translate error messages and on-screen text into Japanese. How locale files are structured, date formats, and how to check Action Mailer email bodies.

🔒 Basic

Chapter 7 — Build and Launch (lessons 46–50)

With credentials and environment variables, asset precompilation, and Docker and Kamal, you'll get your app into a shape you can launch. Finally, you'll compare it side by side with Laravel and get a map of where to go next.

46

Configuration and Secrets (Credentials and Environment Variables)

Where to keep API keys and passwords. Encrypted credentials, handling master.key, and when to use environment variables instead.

🔒 Basic
47

Production Configuration

What changes between development and production. Asset precompilation, logs, caching, force_ssl, and the checks to pass before booting.

🔒 Basic
48

Deploying with Docker and Kamal

Read the Dockerfile rails new creates and ship to a server with Kamal. The build flow, migrations on boot, and rollbacks.

🔒 Basic
49

Comparing It with Laravel

Knowing two full-stack frameworks deepens your understanding of both. Separate what differs only in name from where the thinking differs.

🔒 Basic
50

Wrap-Up (Where to Go from Here)

Count what you built over 50 lessons and finish by passing every test. A list of common commands and a map of what to read next.

🔒 Basic

Once you finish all 50 lessons, move on to Database Fundamentals with PostgreSQL to learn indexes and query plans in depth, PHP & Laravel Intro Course to see the same kind of full-stack framework in another language, or Intro to Shipping and Running a Service to learn how to run things after launch. A membership unlocks every course.