🔥 New Courses: Rails 6 and Full-Stack GraphQL

Ruby on Rails 6

Learn how to pragmatically build and design Rails apps in this step-by-step, project-based course.

This course covers Rails 6, and we also have a Rails 5 course.

Build a full-featured Rails web app from scratch, step by step!

Rails celebrates its 15th anniversary this year, and it's still going strong! Completely updated and re-recorded for Rails 6, this best-selling video course will help you stay on top of your web development game.

Learn how to put all the pieces together to build a complete Ruby on Rails app from idea to deployment in this course. You'll come away with a solid understanding of Rails as well as key design principles and practices to help you craft robust and flexible apps on your own!

This is the best Rails training hands-down! I've worked through several Rails courses and they don't even come close to explaining things as well as you do.” Thomas Neal
This Rails course is fabulous! I took a few other courses, but still felt really confused. I learned a lot, feel more comfortable with Rails...This is my favorite Rails course.” Dana Nourie
Our new hires are loving your online Ruby and Rails courses. In the past, our senior engineers taught new team members Rails on their own. But now with your courses, we are getting new engineers up to speed much easier and faster.” Eirik Holm, AppFolio
“I completed a few Rails tutorials before but this course contained more lightbulb moments than the rest of them put together. The explanations were clean, clear, and precise, and breaking things down into diagrams really helped. I know after completing your courses that I can build pretty much whatever I want in Rails.” Jonathan Mundy

Build a Full-Featured Rails 6 Web App From Scratch

Learn how to rapidly develop and deploy database-driven web apps the Rails way.

You can build amazing web applications with Rails, fast! But a huge part of developer productivity comes from understanding the Rails way of doing things. And the best way to learn Rails is by building real applications from scratch, preferrably with seasoned Rails developers at your side.

In this course, we incrementally build a Rails application step-by-step in the videos so you see exactly how it's done. Then, after each video, you apply what you learned by building another Rails application through a series of guided exercises.

Learning this way makes everything "click", and it's just more fun! 😀

By developing real applications with real code, you'll gain practical experience putting all the pieces together to craft applications using Rails best practices. And you'll come away with a deeper understanding of both the how and the why.

Working in the context of an application, we explore the following topics in-depth:

  • Rails Development Environment
  • Views and Controllers
  • Models and Database Design
  • Migrations
  • Routes
  • Forms
  • The Asset Pipeline
  • One-to-Many Associations
  • User Accounts
  • Authentication and Authorization
  • Many-to-Many and Through Associations
  • Custom Routes
  • Deployment
  • Best Practices, Tips, and Techniques

Now standing up a Rails app that just works isn't the same as designing a good Rails app. Mastering Rails—writing compact, readable, and flexible code—starts by learning the conventions, practices, and idioms fostered by the Rails community.

And having developed with Rails for 15+ years, we've learned our own tips, tricks, and techniques for creating solid Rails apps. So, throughout the course, we discuss design principles and best practices to help you get the most out of Rails!

50 Concise Videos • 44 Chapter Workbook • 8 Hours

Just the way you like 'em: easy to digest, straight to the point, paced just right.
  • Welcome! After taking a peek at the apps we're going to build in this course, we'll help you get your development environment set up so you can start building Rails apps.

  • 2. Create the App (4:34) free

    To make sure everything is up and running smoothly, we start by generating a skeleton Rails app and then get a quick lay of the land.

  • 3. Views and Controllers (7:33 and 8:28) free

    Rails has some strong opinions about how web apps should be designed. You've probably heard about the MVC design in the abstract, but we break it down in practice so you understand where to put your code and the benefits of a decoupled design.

  • 4. Models (7:38 and 11:21)

    Well-designed models are the foundation of any good Rails app. Active Record is the object-relational mapping library that Rails uses to connect your models to your database tables. We don’t yet have a web interface for our app, so instead we see how to create, read, update, and delete records in the database via the console.

  • 5. Connecting MVC (5:57)

    Now that we have some events stored in the database, the next step is to display them on the index page. To do that, the model, view, and controller must all work seamlessly together.

  • 6. Migrations (10:30)

    The details about our events are looking a little sparse. So we add more attributes, which requires knowing how to manage the database schema with migrations.

  • 7. View Helpers (9:20)

    The new event attributes are now displayed on the index page, but their formatting leaves a lot to be desired. We use both built-in and custom view helpers to give our app a lift and make things more reusable. We also answer the question: "Where does business logic belong?"

  • 8. Layouts (3:55)

    To give our app a consistent look and feel, all the common layout elements need to live in one definitive place. Because when it comes to the layout of your app, consistency never goes out of style.

  • 9. Stylesheet and Image Assets (7:44)

    It's always more enjoyable to work on an application that has some style and images. Adding in these assets gives us an opportunity to learn about the Rails asset pipeline.

  • 10. Routes: Show Page (10:08)

    The Rails router receives incoming requests and, depending on a set of rules, dispatches these requests to an appropriate controller action. We start by defining a route that recognizes requests to show an event's details.

  • 11. Routes: Linking Pages (9:14)

    In addition to being able to map requests based on defined routes, the router can also generate URLs that match these routes. We learn how to use route helper methods to generate links to navigate between pages.

  • 12. Forms: Editing Records (12:21 and 11:55)

    Rails has a bunch of conventions to help you create robust and friendly forms with minimal code. We unveil the "magic" as we design a form for editing records, store submitted form data in the database, and display updated records.

  • 13. Forms: Creating Records (14:44)

    Reinforcing what we learned about forms for editing records, we tackle creating records as we continue to implement the full range of CRUD actions using resource routes.

  • 14. Partials (6:56)

    Crafting good Rails apps isn't just about implementing features that work as advertised. Good Rails apps also have clean, well-organized code. To that end, we learn how to use partials to structure the view layer into reusable, manageable chunks.

  • 15. Destroying Records (5:06)

    We finish up implementing the resource routes by deleting records. Here's the cool part: All resources follow the same routes and conventions. So at this point in the course, you can confidently build a CRUD interface for any resource!

  • 16. Custom Queries (6:21)

    Next up, we need to fetch a subset of events from the database and order them in a meaningful way. Thankfully, Active Record has a rich query interface that insulates us from having to write raw SQL to query our data. Master these query methods and you can slice and dice your data with ease, regardless of which database you use.

  • 17. Migrations Revisited (9:57)

    To meet a new requirement, we need to add new fields to a database table. Time for a new migration! And anytime you migrate the database, you also need to think through the ripple effects. Come along as we work through all the steps to accommodate a new migration.

  • 18. Model Validations (10:13)

    To prevent bad (invalid) data from making its way into the database, we add a variety of model validations and explore how they work in detail.

  • 19. Handling Validation Errors (10:57)

    With our model validations in place, we're ready to handle and display any validation errors when submitting form data. You'll come away with a solid strategy for ensuring the integrity of your application's data while providing actionable feedback in the user interface.

  • 20. The Flash (5:26)

    While on the topic of user feedback, we have a few cases where we need to flash a stylish message up on the page. It's common for web apps to flash messages between requests, and so Rails makes it easy.

  • 21. One-to-Many: belongs_to (13:45)

    Up to this point, we've been focused on one resource: events. Now we want to let folks register for events. To do that, we first create a registration resource and then start designing a one-to-many relationship between events and registrations.

    One of the most powerful features of Rails is the ability to easily create these types of associations. But knowing the magic incantations isn't enough. To be empowered, you also need to how what goes on behind the scenes.

  • 22. One-to-Many: has_many (12:07)

    Now it's time to flip over to the other side of the one-to-many association. An event has many registrations, otherwise it wouldn't be a very exciting event. This video shows you how all the dots are connected!

  • 23. One-to-Many: Nested Resources (12:53)

    Registrations only make sense in the context of their associated event. To mimic that one-to-many relationship in our routes, we nest registration resources within an event resource. This is a common design technique that you'll definitely want to have in your arsenal!

  • 24. One-to-Many: Forms (17:19)

    How do you design a form for a one-to-many relationship so you can create child records that are associated with their parent? Answering this gives us an opportunity to apply (and reinforce) everything we've learned so far.

  • 25. One-to-Many: Logic (4:46)

    Once you start making associations between models and collecting data, you'll likely discover some interesting things you can do with it. For example, what does it mean for an event to be sold out? What's the average star rating for a movie? What determines if it's a cult classic? The code that answers those type of questions is part of the business logic of your domain. And knowing where to put that code is vital to designing a maintainable application.

  • 26. User Account Model (13:20)

    User accounts are a central part of any web application. By learning how to design a basic account management and authentication system from scratch, you'll know exactly how it works. With that understanding, you'll have the confidence to roll your own custom solution or integrate (and troubleshoot) a third-party solution.

    We start by designing a solid User model that securely stores passwords using best-practice Rails conventions.

  • 27. User Signup (10:19)

    Now we're ready to design a signup form so users can create accounts and a profile page that displays their account information. To make the sign-up process more friendly, we also add a custom route.

  • 28. Edit User Account (7:48)

    Obviously, users also want to be able to edit their account information, and (dare we say) perhaps even delete their account. Then, with a complete UI for user accounts in place, the stage is set for authentication and other account-related features.

  • 29. Sign In (12:39)

    Now that users can create an account, the next logical step is to let them sign in. We start by designing a sign-in form.

  • 30. Authentication (7:55)

    Next, we confirm you are who you say you are by authenticating a user given their sign-in credentials.

  • 31. Current User (6:57)

    Once authenticated, we use a session to identify the current user as they navigate from page to page.

  • 32. Sign Out (6:58)

    And of course no authentication system would be complete without a way to sign out!

  • 33. Authorization (9:19 and 10:05)

    Now that we know whether a user is signed in or not, it's time to start restricting access to parts of the application. This process is commonly referred to as authorization. And while authorization rules vary widely depending on the nature of the application, once you understand the basic technique you can apply it as you see fit.

  • 34. Admin Users (9:51)

    Only super-special users we trust should be able to perform highly-sensitive actions in our app. So we need a way to distinguish admin users from regular users, and restrict access accordingly.

  • To Be Released Soon...

  • 35. Many-to-Many Associations

  • 36. Another Many-to-Many Association

  • 37. Through Associations

  • 38. Scoped Queries

  • 39. Custom Routes

  • 40. Friendly URLs

  • 41. Deployment

For New Rails Developers

Want to learn and become confident with Rails? We designed this course for you!

Getting started with Rails?

Perhaps you've been intrigued by Rails, but haven't yet had the opportunity to learn it comprehensively from scratch. It all starts here! You'll learn the fundamentals of developing web apps with Rails so you're ready to create your first Rails app or jump right into an existing app. No prior experience with Rails is assumed.

If you're new to the Ruby programming language or new to object-oriented programming in general, we strongly recommend taking our Ruby Programming course prior to this course.

Struggling to put all the pieces together?

Rails is a structured framework that relies on conventions to optimize development time and minimize the amount of code you have to write. This makes developing web apps a bit easier… once you understand how everything fits together. Through live coding, animated visuals, and hands-on exercises, you'll learn how to build a full-featured web app so you're more confident (and less frustrated) writing your own Rails code.

Ready for a refresh and a restart?

If you started learning Rails a while back but haven't used it in earnest, this course will help you quickly get back up to speed with the latest version of Rails and current development techniques!

We aim for 100% satisfied developers, so if this course turns out not to be a good fit for you, we'll gladly issue you a 100% refund.

Created by Mike and Nicole

Hi, we're real people just trying to share our passion for creating stuff!

Howdy! Mike here. I helped build and launch one of the first production Rails apps way back in 2005. I've built countless Rails apps since then, and I continue to develop the Rails apps that power our online business. I co-taught the first official Rails course in 2006 and have had the pleasure of teaching Rails to thousands of developers since then. I'm also the author of Advanced Rails Recipes, co-author of Agile Web Development with Rails, and author of Pragmatic Project Automation.

Together Nicole and I own and run The Pragmatic Studio. We'd love to have you join us in the Studio for this great course! Find out more about us…

Join thousands who have learned Ruby on Rails using this top-rated course!

It is the absolute best for a first dive into Rails! It teaches you the correct way to start a new Rails app...If you go through the whole course, [the] magic will be explained and you’ll know what the Rails framework does instead of passively look at it do things for you.” Nico Schuele
“I really love the quality of your videos and lectures, and the way it builds up an app. It's the best that I've taken!Vita Dewi van Beurden
This is the BEST Rails introduction anywhere on the web! I learned a ton in this course that I didn't learn from other sources online. I was immediately able to start putting together an application that has been stuck in my head for a long time.” Wassim Metallaoui
“Simply amazing. The best online course I have ever experienced. Nicole and Mike, you are the best!” Tony Barone
“This course along with your Ruby Programming course offers the best introduction to learning Rails for a beginning developer. I cannot think of any book or video series that does as good a job.” Eric Ricketts
“I highly recommend Pragmatic Studio's Rails Programming courses! The exercises allow you to build something more complex than a blog and do so by applying what was learned in the lessons rather than merely following along! This format really drove things home for me.Bart Falzarano
“The main difference I have found after taking a lot of other Rails courses is that you explain things in greater detail which has helped me understand the 'whys'.David Theroff
“It seems like there are a lot of courses and tutorials out there that are great if you already know how to program in another language, but there are none that I know of (other than Pragmatic Studio!) that is great for a complete beginner. After taking your Ruby course I feel like I have a solid foundation to stand on. Now, learning Rails has been a lot of fun instead of a lot of frustration.” Andrew Markle
The Rails course is leagues above some others I've tried. First of all, Mike and Nicole have skills as instructors, not just developers, so I didn't feel they were talking above my head. Also it's clear that the lessons and supporting files have been tested and edited -- because they work! The exercises in the example apps are very relevant and I left the course with a whole new level of expertise. I can't recommend this course enough!” Anne Richardson
“I've taken other Rails tutorials but yours really filled in the gaps in my understandings. I can now truly say that I've taken a big step towards developing with Rails.” John Weir
“Everything is great: the material, the teachers, the simple, concise, yet clear explanations in all the courses. I think these are the best Ruby and Rails online courses for people that want to jump into Rails. All of the courses are worth every penny!” Alfian Losari
“This course is fantastic! I had read a couple of Rails tutorial books and sort of understood what the example code was doing, but was having trouble sorting out how to build my own app. This course really filled in some missing pieces.” Terrence Talbot
“After trying many online Ruby on Rails courses across the Internet, this is the most thorough and enjoyable introduction available. Rhys Yorke
“A partner and I just released and started getting sales on an RoR app I created. I was able to build the prototype in a weekend! You all are a big reason I was able to do it. You have done a wonderful job of taking a lot of the 'magic' out of Rails.Justin Seiter
“Coming into the course, I had so many loose ends regarding how Rails worked, but I finished the course with the confidence to create my own app.Brad Ballard