One Rails method at a time, coded live.
GoRails Screencasts builds each lesson around a single piece of Rails, such as in_order_of, with_options, normalizes or validation contexts, and shows it working in a small demo app. The pace is casual and hands-on: the browser gets refreshed, the console gets checked, and small typos get fixed on screen.
PRESS PLAY
GoRails Screencasts is a Ruby on Rails tutorial series that works at the level of the individual method. A lesson picks one tool from the framework, explains the problem it solves, and then makes it run inside a small demo app. The demo apps are plain. There is a task list with statuses like urgent, in progress, pending and done, a scaffolded examples model with an optional field, and a post that needs a title and body before it can be published. With so little else on screen, the method gets all the attention. The teaching style is conversational and visibly live. Several lessons open with a casual greeting, code is typed in real time, and the browser gets refreshed to check the result. When something breaks, it gets fixed on screen: in 'ActiveRecord in_order_of', a stray space causes a syntax error that is corrected before the lesson continues. That same lesson lays out a plain Ruby route to a custom order, mapping each status to a number in a hash and sorting with sort_by. Results get checked in more than one place. The normalizes lessons query the Rails console for what was saved and read the server log to show the browser submitting an empty string. 'Clean Up Optional Attributes in Rails with Normalizes' fixes that with a lambda that calls presence, which returns the value or nil, so a blank field is stored as a null rather than an empty string. 'Normalize All ActiveRecord Attributes' refers back to a previous lesson on that technique and adds a second optional field to show the gap left when only one attribute is normalized. Reading other people's code is one way lessons get started. 'valid with Context' opens with a greeting for the new year of 2026 and the view that reading code by more seasoned developers is one of the best ways to learn. It then opens a signup model in Basecamp's Fizzy app, spots validations scoped to a context, and rebuilds the idea around a publish method that checks title and body only when a post is being published. The closing point is that the same context can be passed to save as well as to valid. 'Removing Duplication Using with_options' likewise comes from browsing a codebase, then turns to the Rails API docs to show options merged into every call inside the block, including an example built on associations that share dependent destroy. Community questions feed the series too. 'Dynamic Partial Rendering' takes a question from the GoRails Discord group about type checking in a view, shows Rails rendering partials for single table inheritance models on its own, and uses string interpolation to reach the right edit partial for single-unit and multi-unit properties. It also notes a linter rule the approach runs into and leaves the final call to the developer.
Made for: Suits a developer who already works in Ruby on Rails and wants to add specific framework methods, such as normalizes, with_options or in_order_of, to their toolkit by watching them run in a small app.
What sets it apart: Each lesson covers a single Rails method or pattern and is coded live, with slips and console checks left in. Some lessons start from real code in Basecamp's Fizzy app or from a question in the GoRails Discord group rather than an invented exercise.
GoRails is a series of screencasts and guides for all aspects of Ruby on Rails. Learn how to setup your machine, build a Rails application, and deploy it to a server.
A blank draft gets mercy; your publish button gets context-specific Rails rules.
Press play if you want
Short reviews from the PlayNext desk, based on the episodes we processed.
A concise Rails review showing how validation contexts keep drafts flexible until a post is ready to publish.
Rails validation contexts make a familiar model feel newly practical by tying rules to intent. This short review follows a signup model that conditionally runs validations, then carries the same idea into a simple blog app: drafts can live with an empty title or body, while…
A clear Hatchbox walkthrough that keeps Rails deployment practical, visible, and owner-controlled.
A Rails blog deployment with Hatchbox becomes a grounded look at how a small Rails app gets onto a server. The host works from a Postgres-backed blog through repository settings, main-branch deployment, environment variables, database setup, and the moment a server needs an…
A practical Go Rails walkthrough of Ruby pattern matching, from nested data to custom deconstruction.
Go Rails treats Ruby pattern matching as a working tool for nested data, not just a neat syntax feature. It begins with deep matching across arrays and hashes, then builds through case/in expressions, shorthand forms, variable binding, and exhaustive matching.
Power Platform news with practical static.
This episode explains how to configure multiple databases in a Rails application, focusing on the solid gems introduced in Rails 8.
The host introduces Hatchbox for deploying Rails apps and demonstrates creating a simple blog app with Rails, Postgres, and Tailwind.
Colin from GoRails demonstrates how to use the in_order_of method in Active Record to sort tasks by custom status priority.
This episode explains how to use the with_options method in Rails to factor out duplication of options passed to multiple method calls within a block.
This episode explains how to normalize multiple optional ActiveRecord attributes in Rails to convert empty strings to nil.
This episode demonstrates how to refactor a view with conditional rendering for different property types by using dynamic partials in Rails.
How to use Rails' normalizes method to convert empty strings to nil for optional attributes in forms.
["GoRails Screencasts centers on Rails validation contexts, starting from Basecamp's Fizzy app and a `signup.rb` model that passes a context into `complete`.", "The presenter builds a tiny blog app with `title` and `body` fields, then adds `save draft` and `publish` buttons to separate draft saving from publishing.", "`binding.irb` shows that the clicked button arrives as `params[:publish]`, which drives the choice between saving without validation and enforcing presence checks.", "The final refactor uses `save(context: :publish)` so the controller keeps the same behavior while removing the explicit validation branch."]
GoRails Screencasts walks through deploying a Rails 8 blog with Hatchbox, starting from `Rails new my blog` and ending on a live Hatchbox URL.
Go Rails explains Ruby pattern matching as deep matching across nested arrays and hashes, with matched values bound to local variables.
Testing Thanksgiving across 2024, 2025, 2026, and 2029 exposes why the gem needs an explicit year argument.
bin importmap downloads NPM packages into vendor JavaScript, avoiding runtime dependence on a CDN.
This episode covers the new Noticed Version 2 gem for Rails notifications, including setup and migration from version 1.
This episode teaches how to convert a Ruby script into a gem with an executable for easy sharing and error handling.
This episode demonstrates a Ruby script to automate syncing multiple Git repositories by fetching from upstream and pushing to origin.